> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tightknit.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Tutorial: Running Simultaneous Events Across Multiple Zoom Accounts

> Auto-route event registrations across multiple Zoom accounts while keeping the native Tightknit registration experience.

In this tutorial, we will use Tightknit webhooks and the Admin API to automatically detect which Zoom account is free, create the meeting on that account, and deliver each registrant a personalized join link — all through the native Tightknit experience.

Two automations run in the background:

* **Automation 1 — On event publish:** Checks each connected Zoom account for scheduling conflicts, creates a meeting on the first free account, and stores the join URL.
* **Automation 2 — On registration:** Retrieves the stored join URL and calls the Tightknit API to set a `personal_join_link` on the attendee. Members then see a native **"Join Event"** button in their event reminders and events list.

<Steps>
  <Step title="Create two webhook endpoints in Tightknit">
    In the Tightknit [webhooks](/integrations/webhooks) admin portal, create two endpoints:

    | Endpoint                  | Event types to subscribe         |
    | ------------------------- | -------------------------------- |
    | Endpoint 1 (Automation 1) | `calendar_event.published`       |
    | Endpoint 2 (Automation 2) | `calendar_event.user_registered` |

    You'll fill in the URLs from your automation tool in the next steps.
  </Step>

  <Step title="Enable webhooks on each event">
    When creating or editing a Tightknit event, open **Registration Settings** and check **Enable Webhooks**. No other configuration is needed — the automation detects the right Zoom account automatically.
  </Step>

  <Step title="Build Automation 1 — Auto-detect a free Zoom account and create the meeting">
    This automation fires when a Tightknit event is published. It checks each Zoom account for a scheduling conflict, creates a meeting on the first free account, and stores the join URL.

    <Tabs>
      <Tab title="Zapier">
        Create a new Zap with a **Webhooks by Zapier > Catch Hook** trigger. Copy the URL and paste it into Endpoint 1 in Tightknit.

        Click **Test trigger**, then publish a test event to capture sample data. Confirm you can see `event.id`, `event.start_date`, and `event.end_date`.

        Add a **Webhooks by Zapier > GET** action to call `https://api.zoom.us/v2/users/me/meetings?type=scheduled` connected to **Account A**, then add a **Code by Zapier** step to check for conflicts:

        ```js theme={null}
        const eventStart = new Date(inputData.event_start).getTime();
        const eventEnd = new Date(inputData.event_end).getTime();
        const meetings = JSON.parse(inputData.meetings || '[]');

        const hasConflict = meetings.some(m => {
          const mStart = new Date(m.start_time).getTime();
          const mEnd = mStart + (m.duration * 60 * 1000);
          return mStart < eventEnd && mEnd > eventStart;
        });

        output = [{ has_conflict: hasConflict ? 'true' : 'false' }];
        ```

        Add a **Paths** step to route based on the result:

        * **Path A:** `Has Conflict` exactly matches `false` → create meeting on **Account A**
        * **Path B:** `Has Conflict` exactly matches `true` → create meeting on **Account B**

        Inside each path, add a **Zoom > Create Meeting** action (map `Event Title`, `Event Start Date`, and duration from the trigger). Then add a **Storage by Zapier > Set Value** action:

        * **Key:** `zoom_meeting_{{event.id}}`
        * **Value:** `Join URL` from the Create Meeting step

        Turn the Zap on.

        <Note>
          To support three or more accounts, add a second conflict check inside Path B before creating the meeting, following the same pattern.
        </Note>
      </Tab>

      <Tab title="Make">
        Create a new scenario with a **Webhooks > Custom webhook** trigger. Copy the URL and paste it into Endpoint 1 in Tightknit.

        Click **Run once**, then publish a test event to capture sample data. Confirm the payload includes `event.id`, `event.start_date`, and `event.end_date`.

        Add an **HTTP > Make a request** module for Account A (`GET https://api.zoom.us/v2/users/me/meetings?type=scheduled&page_size=300`), then add a **Tools > Set variable** module to compare each meeting's `start_time` and `start_time + duration` against the event window. Set `account_a_free` to `true` if no overlap exists.

        Add a **Flow control > Router** with two branches:

        * **Branch A:** `account_a_free` equal to `true` → create meeting on **Account A**
        * **Branch B:** `account_a_free` equal to `false` → create meeting on **Account B**

        On each branch, add a **Zoom > Create a Meeting** module (map `event.title`, `event.start_date`, and duration). Then add a **Data Stores > Add/Replace a Record** module:

        * **Key:** `{{event.id}}`
        * **zoom\_join\_url:** `join_url` from the Zoom module

        Save and toggle the scenario on.

        <Note>
          To support three or more accounts, add a second HTTP + conflict check on Branch B before creating the meeting, following the same pattern.
        </Note>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Build Automation 2 — Deliver the join link on registration">
    This automation fires when a member registers. It retrieves the stored join URL and sets it on the attendee record so they receive a native "Join Event" button.

    <Tabs>
      <Tab title="Zapier">
        Create a new Zap with a **Webhooks by Zapier > Catch Hook** trigger. Copy the URL and paste it into Endpoint 2 in Tightknit.

        Click **Test trigger**, then register for the test event in Slack. Confirm the payload includes `event.id` and `user.slack_user_id`.

        Add a **Storage by Zapier > Get Value** action with **Key:** `zoom_meeting_{{event.id}}`.

        Add a **Webhooks by Zapier > POST** action:

        * **URL:** `https://api.tightknit.ai/admin/v0/calendar_events/{{event.id}}/attendees`
        * **Payload Type:** JSON
        * **Data:**
          ```json theme={null}
          {
            "user": { "slack_user_id": "{{user.slack_user_id}}" },
            "personal_join_link": "{{retrieved_join_url}}"
          }
          ```
        * **Headers:** `Authorization: Bearer YOUR_TIGHTKNIT_API_KEY`

        Turn the Zap on.
      </Tab>

      <Tab title="Make">
        Create a new scenario with a **Webhooks > Custom webhook** trigger. Copy the URL and paste it into Endpoint 2 in Tightknit.

        Click **Run once** and register for the test event in Slack. Confirm the payload includes `event.id` and `user.slack_user_id`.

        Add a **Data Stores > Search Records** module. Search by key `{{event.id}}` and map `zoom_join_url` from the result.

        Add an **HTTP > Make a request** module:

        * **URL:** `https://api.tightknit.ai/admin/v0/calendar_events/{{event.id}}/attendees`
        * **Method:** PATCH
        * **Headers:** `Authorization: Bearer YOUR_TIGHTKNIT_API_KEY`, `Content-Type: application/json`
        * **Body:**
          ```json theme={null}
          {
            "user": { "slack_user_id": "{{user.slack_user_id}}" },
            "personal_join_link": "{{zoom_join_url}}"
          }
          ```

        Save and toggle the scenario on.
      </Tab>
    </Tabs>

    <Info>
      You can create a Tightknit API key in your [API settings](/integrations/api-keys).
    </Info>
  </Step>

  <Step title="Test end to end">
    1. Create a test event in Tightknit with **Enable Webhooks** checked.
    2. Publish the event. Confirm Automation 1 ran — check your storage for a join URL and verify the meeting was created on the expected Zoom account.
    3. Publish a second event at the same time. Confirm it was assigned to a different Zoom account.
    4. Register for one of the events in Slack as a test user.
    5. Confirm Automation 2 ran — the member should see a **"Join Event"** button in their Tightknit event reminder.
  </Step>
</Steps>

## Related Resources

<CardGroup>
  <Card title="⚡ Zapier Webhook → Zoom Webinar" href="/events/tutorials/webhook-zapier-zoom" />

  <Card title="⚡ Make Webhook → Zoom" href="/events/tutorials/webhook-make-zoom" />

  <Card title="Event Registration" href="/events/event-registration" />

  <Card title="Webhooks" href="/integrations/webhooks" />
</CardGroup>


## Related topics

- [Tutorial: Zapier Webhook → Zoom](/events/tutorials/webhook-zapier-zoom.md)
- [Tutorial: Make Webhook → Zoom](/events/tutorials/webhook-make-zoom.md)
- [Zoom Meeting Templates](/guides/zoom-meeting-template-guide.md)
- [Event Registration](/events/event-registration.md)
- [Tutorial: Make Webhook → Slack notification](/events/tutorials/webhook-make-slack.md)