ContextQMD
Back to Twenty

Create Many-to-Many Relations

packages/twenty-docs/user-guide/data-model/how-tos/create-many-to-many-relations.mdx

2.2.06.0 KB
Original Source

Many-to-many relations let you connect multiple records on both sides. For example: many People can work on many Projects, and each Project can have many People.

<Warning> **Lab Feature**: Junction relations are currently in the Lab. Enable them at **Settings → Updates → Lab** before following this guide. </Warning> <Note> This feature also requires **Advanced mode** to be enabled (toggle at the bottom right of Settings). </Note>

When to Use Many-to-Many

Use many-to-many when both sides of a relationship can have multiple connections:

RelationshipExample
People ↔ ProjectsA person works on multiple projects; a project has multiple team members
Companies ↔ TagsA company can have multiple tags; a tag can apply to multiple companies
Products ↔ OrdersA product can be in multiple orders; an order contains multiple products

How It Works

Twenty uses a junction object pattern for many-to-many relations. A junction object sits between two objects and holds the connections:

People ←→ Project Assignments ←→ Projects

The Project Assignments object (junction) has:

  • A relation to People (many-to-one)
  • A relation to Projects (many-to-one)

When you enable the junction relation toggle, Twenty displays linked records directly instead of showing the intermediate junction records.

Prerequisites

  1. Enable Junction Relations in Lab: Go to Settings → Updates → Lab and enable Junction Relations
  2. Enable Advanced mode: Toggle on Advanced mode at the bottom right of the Settings sidebar
  3. Plan your data model:
    • Which two objects are you connecting?
    • What should the junction object be called?

Step 1: Create the Junction Object

First, create the intermediate object that will hold the connections.

  1. Go to Settings → Data Model

  2. Click + New object

  3. Name it descriptively (e.g., "Project Assignment", "Team Member", "Product Order")

  4. Toggle "Skip creating a Name field" on

  5. Click Save

<Tip> **Naming convention**: Use a name that describes the relationship, like "Project Assignment" or "Team Membership". This makes the data model easier to understand. </Tip>

Step 2: Create Relations Between Objects and the Junction

Add relation fields from each of your two objects to the junction object.

First Relation (Object A → Junction)

  1. Select your first object in Settings → Data Model
  2. Click + Add Relation
  3. Select the junction object (e.g., "Project Assignments")
  4. Set the relation type to One-To-Many (one person can link to many assignments)
  5. Name the fields:
    • Field on People: e.g., "Project Assignments"
    • Field on junction: e.g., "Person"
  6. Click Save

Second Relation (Object B → Junction)

  1. Select your second object in Settings → Data Model

  2. Click + Add Relation

  3. Select the junction object (e.g., "Project Assignments")

  4. Set the relation type to One-To-Many (one project can link to many assignments)

  5. Enable "This is a relation to a Junction Object"

  6. Name the fields:

    • Field on junction: e.g., "Project"
    • Field on Projects: e.g., "Team Members"

  7. Click Save

Step 3: Configure the Junction Relation Display

Now configure the source objects to display linked records directly, skipping the intermediate junction object.

  1. Go to Settings → Data Model
  2. Select the first object (e.g., "People")
  3. Find the relation field pointing to the junction object (e.g., "Project Assignments")
  4. Click to edit the field
  5. Enable "This is a relation to a Junction Object"
  6. Select the Target relation (e.g., "Project" — the field on the junction that points to the other side)
  7. Click Save

Result

After configuration:

  • On a Person record, the "Project Assignments" field displays Projects directly (not assignment records)
  • On a Project record, the "Team Members" field displays People directly

The junction object still exists and stores the connections, but the UI presents a cleaner many-to-many view.

Example: People ↔ Projects

Here's a complete walkthrough:

Create the Junction Object

  • Name: Project Assignment
  • Description: "Links people to projects they work on"

Add Relations

  1. People → Project Assignment

    • Type: One-to-Many
    • Field on People: "Project Assignments"
    • Field on Assignment: "Person"

  2. Projects → Project Assignment

    • Type: One-to-Many
    • Field on Projects: "Team Members"
    • Field on Assignment: "Project"

Configure Junction Display

  1. On People object:

    • Edit "Project Assignments" field
    • Enable junction toggle
    • Target: "Project"

  2. On Projects object:

    • Edit "Team Members" field
    • Enable junction toggle
    • Target: "Person"

Use It

  • Open a Person record → See their Projects directly
  • Open a Project record → See team members directly
  • Create new connections from either side

Adding Extra Data to Connections

Since the junction object is a real object, you can add custom fields to store information about the relationship:

  • Role: "Developer", "Designer", "Manager"
  • Start Date: When they joined the project
  • Hours Allocated: Weekly hours on this project

To access this data, navigate to the junction object directly or query it via the API.

Limitations

  • CSV Import/Export: Importing many-to-many relations directly is not supported. Import records to the junction object instead.
  • Filters: Filtering by many-to-many relations may have limited options.