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

# How to set up webhooks with Fathom on Nango

> Learn how to receive real-time Fathom recording events in your app using Nango webhooks

Fathom sends a webhook once a recording finishes processing — there's a single event, `new-meeting-content-ready`, so no event-type filtering is needed on your side.

## How it works

1. Fathom sends a POST request to your Nango webhook URL when a recording you're subscribed to finishes processing.
2. Nango verifies the delivery's signature (if you've set a **Webhook secret**), then routes the event to a connection.
3. The payload includes the transcript, summary, and action items you asked for when creating the webhook — there's no separate API call needed to fetch them.

## Setup

### 1. Get your Nango webhook URL

In the Nango dashboard, open your Fathom integration and copy the **Webhook URL**.

### 2. Create the webhook in Fathom

<Tabs>
  <Tab title="Fathom dashboard">
    1. Go to **Settings → API Access → Manage** and select **Add Webhook**.
    2. Enter your Nango webhook URL as the destination — see [Connection matching](#connection-matching) below for whether to append `?nangoConnectionId=<CONNECTION-ID>`.
    3. Choose which recordings trigger it (your own, shared with you, shared with your team) and which content to include (transcript, summary, action items, CRM matches).
    4. Save the webhook and copy the **secret** it generates — you'll only see it once. You'll use it in the next step.
  </Tab>

  <Tab title="Fathom API">
    Register your endpoint with Fathom's create webhook API, through Nango's proxy:

    ```bash theme={null}
    curl -X POST "https://api.nango.dev/proxy/external/v1/webhooks" \
      -H "Authorization: Bearer <NANGO-API-KEY>" \
      -H "Provider-Config-Key: <INTEGRATION-ID>" \
      -H "Connection-Id: <CONNECTION-ID>" \
      -H "Content-Type: application/json" \
      -d '{
        "destination_url": "<NANGO-WEBHOOK-URL>",
        "triggered_for": ["my_recordings", "my_shared_with_team_recordings"],
        "include_transcript": true,
        "include_summary": true,
        "include_action_items": true
      }'
    ```

    At least one of `include_transcript`, `include_crm_matches`, `include_summary`, or `include_action_items` must be `true`. Fathom generates the `secret` and returns it in the response — save it, you'll need it in the next step. The response also includes an `id` you'll need to delete the webhook later (see [Rollback strategy](#rollback-strategy)).
  </Tab>
</Tabs>

### 3. Set the webhook secret in Nango

Where you store the secret Fathom returned depends on which routing mode you use — see [Connection matching](#connection-matching) below.

* **Email-routed** (no `nangoConnectionId`): in the Nango dashboard, open your Fathom integration, go to the **Settings** tab, and enter the secret into the **Webhook Secret** field.
* **`nangoConnectionId`-routed**: store the secret on that specific connection's metadata instead — see step 4 below. Do **not** use the integration-level **Webhook Secret** field for this mode.

<Note>
  If no **Webhook secret** is set on the integration, Nango accepts email-routed deliveries without verifying their signature. Deliveries using `nangoConnectionId` always require a **webhook secret set on that specific connection** — see [Connection matching](#connection-matching).
</Note>

### 4. For `nangoConnectionId` routing: create one webhook per connection

Fathom issues a distinct secret each time you create a webhook, so a single integration-level secret can't verify deliveries for more than one `nangoConnectionId`-routed connection. If you're routing more than one connection this way, repeat step 2 to create a **separate Fathom webhook per connection** — each with its own destination URL (`?nangoConnectionId=<CONNECTION-ID>`) and its own secret — then store each connection's secret as `webhookSecret` in that connection's metadata via [Set connection metadata](/docs/reference/backend/http-api/connections/set-metadata).

## Connection matching

A Fathom workspace can have multiple team members recording meetings, so Nango supports two ways to route a delivery to a connection:

* **By email (default)** — if the destination URL has no `nangoConnectionId` query param, Nango matches the event's `recorded_by.email` against **`metadata.emailAddress`** on your connections. Use this when you have one Nango connection per team member and want each person's recordings routed to their own connection. Set `metadata.emailAddress` on each connection via [Set connection metadata](/docs/reference/backend/http-api/connections/set-metadata). Signature verification, if enabled, uses the integration-level **Webhook Secret**.
* **By `nangoConnectionId`** — append `?nangoConnectionId=<CONNECTION-ID>` to the destination URL when creating the webhook. Every delivery for that webhook routes to that one connection regardless of who recorded it. Because the connection is chosen from a value in the URL, Nango requires a **webhook secret set on that connection's metadata** (not the integration-level one) to verify it — a delivery with `nangoConnectionId` is rejected if the connection doesn't exist, has no `webhookSecret` in its metadata, or its signature doesn't verify against it. If you route multiple connections this way, each needs its own Fathom webhook and its own secret — see step 4 above.

If neither matches — no `nangoConnectionId` and no connection has a matching `metadata.emailAddress` — the delivery is still accepted, but isn't routed anywhere.

## Handle the webhook

Once routed, you have two options:

* **Forward it to your app** — Nango forwards the event to your webhook URL with connection attribution. See [External webhook forwarding](/docs/guides/platform/webhook-forwarding).
* **Process it in a sync** — run a sync when the webhook arrives using `webhookSubscriptions` and `onWebhook` in a sync script. See [Real-time syncs](/docs/guides/functions/syncs/realtime-syncs).

## Rollback strategy

To stop deliveries, delete the webhook using the `id` Fathom returned when you created it:

```bash theme={null}
curl -X DELETE "https://api.nango.dev/proxy/external/v1/webhooks/<WEBHOOK-ID>" \
  -H "Authorization: Bearer <NANGO-API-KEY>" \
  -H "Provider-Config-Key: <INTEGRATION-ID>" \
  -H "Connection-Id: <CONNECTION-ID>"
```

Or delete it from **Settings → API Access → Manage** in the Fathom dashboard.

If you created multiple webhooks for `nangoConnectionId` routing (one per connection, per [step 4](#4-for-nangoconnectionid-routing-create-one-webhook-per-connection)), repeat this for each webhook `id`.

<Tip>Need help getting started? Join us in the [community](https://nango.dev/slack).</Tip>