Hi Chan, here an exemple of how I use POST to add user into membership in Python.

I have my object Membership construct, from the project id, the user id, and the role id :

class Membership:

    def __init__(self, project_id, user_id, role_id):
        self.project_id = project_id
        self.user_id = user_id
        self.role_id = role_id

    def to_json(self):
        membership = {
            "_links": {
                "project": {
                    "href": "/api/v3/projects/" + str(self.project_id)
                },
                "principal": {
                    "href": "/api/v3/users/" + str(self.user_id)
                },
                "roles": [
                    {
                        "href": "/api/v3/roles/" + str(self.role_id)
                    }
                ]
            }
        }

        return json.dumps(membership)

After I just send the POST request, passing the route your_openproject_url + api/v3/membership/ ,  and my object membership.to_json() :

    def op_post_request(self, route, data):
        url = self.op_base_url + route
        result = requests.post(url, auth=(self.op_username, self.op_userkey), data=data,
                               headers={'content-type': 'application/json'}, timeout=5)
        return json.loads(result.content)

Hope it helps you !

Thankyou Thomas!
This actually helps me understand the other endpoint too!
and it works!

Adding a user to a project in app creation involves several steps, depending on the specific app development platform or tool you are using. Here is a general overview of the process:

Access project settings: Log in to your app development platform or tool and access the project settings or configuration page.

Add user: Locate the option to add a user to the project, which may be located under the "Collaboration" or "Team" section. Enter the user's email address or username and select the appropriate access level or role for the user.

Send invitation: Once you have added the user to the project, send them an invitation to join the project. The invitation may be sent via email or through the app development platform or tool.

Accept invitation: The user will need to accept the invitation to join the project. They may need to create an account or log in to the app development platform or tool if they do not already have an account.

Set permissions: Once the user has joined the project, you can set their permissions or access level for the project. This may include permissions to view or edit certain files or sections of the app, or to deploy the app to production.

Overall, adding a user to a project in app creation involves several steps and may vary depending on the specific app development platform or tool you are using. It is important to follow the instructions provided by the platform or tool and to ensure that the user has the appropriate permissions and access level for the project.

Creating an app and adding users to a project involves several steps, including designing the app, setting up user authentication, and managing user roles within the project. Below is a general outline of the process:

1. **App Design and Development:**
  - Define the purpose and features of your app.
  - Choose the appropriate technology stack (programming languages, frameworks, etc.).
  - Design the user interface (UI) and user experience (UX) of the app.
  - Develop the app's functionality according to the defined features.

2. **User Authentication:**
  - Implement user authentication to secure your app and ensure that only authorized users can access it.
  - Choose an authentication method (e.g., email and password, social media logins, single sign-on).
  - Integrate an authentication library or service to handle user registration, login, and session management.

3. **Database Setup:**
  - Choose a database system (SQL, NoSQL, etc.) to store app data, including user information and project details.
  - Set up the necessary tables or collections to store user and project data.

4. **Adding Users to a Project:**
  - Design a feature that allows project owners or administrators to add users to their projects.
  - Create a form or interface where project owners can enter the email addresses or usernames of users they want to add.

5. **User Roles and Permissions:**
  - Define different user roles within the project, such as owner, administrator, member, guest, etc.
  - Implement role-based access control (RBAC) to ensure that users have appropriate permissions based on their roles.

6. **Backend Implementation:**
  - Implement backend logic to handle user invitations and confirmations.
  - Generate unique invitation tokens or links that are sent to users via email.

7. **Email Notifications:**
  - Integrate email services to send notifications to users when they're invited to a project.
  - Include a link or token that allows users to accept the invitation and join the project.

8. **Frontend Implementation:**
  - Create a frontend interface where users can view and accept project invitations.
  - Provide a user-friendly experience for accepting invitations and managing project memberships.

9. **Testing:**
  - Thoroughly test the app's user invitation and project membership features.
  - Test various scenarios, such as accepting invitations, declining invitations, and managing project roles.

10. **Deployment:**
  - Deploy your app to a hosting environment or platform of your choice.
  - Ensure that the app is accessible to users and that email notifications are working correctly.

11. **Ongoing Maintenance:**
  - Continuously monitor the app for any issues related to user invitations, project memberships, and user roles.
  - Implement updates and improvements based on user feedback and changing requirements.

Creating an app that allows users to be added to a project involves several steps. Below, I'll outline a basic process to get you started:

1. **Define Project Scope**:
  - Clearly define the purpose and scope of your app. Understand what functionality you want to provide for adding users to projects.

2. **Choose Development Platform**:
  - Decide whether you're building a web application, a mobile app, or both. This will influence the technologies you'll use.

3. **Select Development Tools and Stack**:
  - Choose the programming languages, frameworks, and tools you'll use. For example, if building a web app, you might use JavaScript (with a framework like React or Angular), HTML, CSS, and a backend technology like Node.js or Python.

4. **Set Up User Authentication and Authorization**:
  - Implement a user authentication system to allow users to create accounts and log in. Also, establish authorization mechanisms to control access to projects.

5. **Create a Database**:
  - Set up a database to store project information and user data. Choose a database technology (e.g., MySQL, PostgreSQL, MongoDB) and design the schema.

6. **Design the User Interface**:
  - Create the UI components for user registration, login, and project management. Make sure the interface is intuitive and user-friendly.

7. **Implement User Registration and Login**:
  - Create forms and backend logic to handle user registration and login. Use secure practices like password hashing and encryption.

8. **Project Creation and Management**:
  - Develop functionality to allow users to create projects. This may involve defining project details, assigning members, setting permissions, etc.

9. **Add Users to Projects**:
  - Implement a feature that allows project owners or admins to invite and add users to their projects. This could involve sending invitations via email or generating shareable links.

10. **Handle User Roles and Permissions**:
   - Define different roles (e.g., admin, member, viewer) within a project and implement appropriate permissions for each role.

11. **Testing**:
   - Thoroughly test the app to identify and fix any bugs or issues. Test various scenarios for adding users to projects.

12. **Deployment**:
   - Choose a hosting solution (e.g., cloud platform like AWS, Heroku) and deploy your app. Ensure it's accessible to users.

13. **Monitor and Maintain**:
   - Monitor the app for performance, security, and user feedback. Regularly update and maintain the app to fix bugs and add new features.

Remember, this is a high-level overview. Depending on the complexity of your app and the technologies you choose, there will be specific details to consider in each step. Also, always prioritize security, especially when dealing with user authentication and authorization.