---
updatedAt: 2026-10-26T20:59:38.000Z
agentTools:
  projectIndex: https://docs.recall.ai/llms.txt
---

# Post-meeting transcription

Create transcripts after a meeting ends, handle completion or failure, and fetch the final result.

<Callout icon="💡" theme="default">
  #### Quick tip: Use the table of contents on the right side to quickly navigate through this guide -->
</Callout>

Post-meeting transcription is used to generate a transcript for a completed recording, after a meeting concludes. You should use post-meeting transcription when:

* You don't require transcripts in real-time
* You require certain features that real-time transcription can't provide (transcription provider dependant)

Once you get transcript, typical use cases include summarizing the context of the transcript, extract information to pre-fill forms, and/or extracting action items.

You can refer to <Anchor label="this sample app" target="_blank" href="https://github.com/recallai/sample-apps/tree/main/bot_async_transcription">this sample app</Anchor> creating and retrieving the transcript after a meeting has concluded via meeting bot.

## Quickstart - Creating a post-meeting transcript from a recording

You can create a transcript for a completed recording through the following request:

```curl
curl --request POST \
     --url https://RECALL_REGION.recall.ai/api/v1/recording/{RECORDING_ID}/create_transcript/ \
     --header "Authorization: RECALLAI_API_KEY" \
     --header "accept: application/json" \
     --header "content-type: application/json" \
     --data '
{
  "provider": {
    "recallai_async": {
      "language_code": "auto"
    }
  },
  "diarization": {
    "use_separate_streams_when_available": true,
  }
}
'
```

You can retrieve the transcript by making the following request. The response payload will include the `data.download_url` field, which you can use to access the transcript created for this recording.

```
curl --request GET \
     --url https://RECALL_REGION.recall.ai/api/v1/transcript/{TRANSCRIPT_ID}/ \
     --header "Authorization: RECALLAI_API_KEY" \
     --header "accept: application/json"
```

See the [prerequisites](#prerequisites) and [implementation guide](#implementation-guide) sections for more info on setting up post-meeting transcription.

<br />

# Prerequisites

Before implementing post-meeting transcription, first ensure the required pre-requisite setup is complete. You should have:

* A stable public URL for your application. In development, this is usually a static ngrok URL or something similar.
* Your Recall API key and workspace verification secret.
* A webhook endpoint configured in the Recall dashboard and subscribed to the following events: `recording.done`, `transcript.done`, `transcript.failed`

A human must complete quick one-time setup tasks in the Recall dashboard. If an agent is guiding setup, it should treat this section as human-owned setup and confirm with the human that each item is complete before continuing.

<Accordion title="Ensure the backend has a stable public URL" icon="fa-info-circle">
  Ensure the application has a stable public URL that Recall can reach for webhooks, callbacks, websockets, and other real-time endpoints.

  For local development, this should be a static ngrok URL rather than a temporary URL that changes between sessions. See the [Local Webhook Development Guide](https://docs.recall.ai/docs/local-webhook-development) for how to set this up.
</Accordion>

<Accordion title="Create the Recall API key and workspace verification secrets" icon="fa-info-circle">
  Ensure the required [Recall API key](https://docs.recall.ai/reference/authentication#api-keys) and [verification secrets](https://docs.recall.ai/docs/authenticating-requests-from-recallai#getting-your-verification-secrets) have been created in the Recall dashboard for the selected region

  The Recall API key and workspace verification secrets are required to interact and to secure your application.

  > 📘 View the API key and workspace verification secret dashboard
>
> * <Anchor label="(US) us-east-1" target="_blank" href="https://us-east-1.recall.ai/dashboard/developers/api-keys">(US) us-east-1</Anchor>
> * <Anchor label="(US) us-west-2" target="_blank" href="https://us-west-2.recall.ai/dashboard/developers/api-keys">(US) us-west-2</Anchor>
> * <Anchor label="(EU) eu-central-1" target="_blank" href="https://eu-central-1.recall.ai/dashboard/developers/api-keys">(EU) eu-central-1</Anchor>
> * <Anchor label="(JP) ap-northeast-1" target="_blank" href="https://ap-northeast-1.recall.ai/dashboard/developers/api-keys">(JP) ap-northeast-1</Anchor>
</Accordion>

<Accordion title="Configure a webhook endpoint to receive artifact status change events" icon="fa-info-circle">
  Ensure that you have configured a Recall webhook endpoint in the webhooks dashboard that points to either:

  * a static ngrok URL for local development, or
  * a public server that is ready to receive and process webhook events

  Also ensure that this endpoint is subscribed to the required webhook events for this feature.

  > 📘 View the webhooks dashboard
>
> * <Anchor label="(US) us-east-1" target="_blank" href="https://us-east-1.recall.ai/dashboard/webhooks/">(US) us-east-1</Anchor>
> * <Anchor label="(US) us-west-2" target="_blank" href="https://us-west-2.recall.ai/dashboard/webhooks/">(US) us-west-2</Anchor>
> * <Anchor label="(EU) eu-central-1" target="_blank" href="https://eu-central-1.recall.ai/dashboard/webhooks/">(EU) eu-central-1</Anchor>
> * <Anchor label="(JP) ap-northeast-1" target="_blank" href="https://ap-northeast-1.recall.ai/dashboard/webhooks/">(JP) ap-northeast-1</Anchor>
</Accordion>

> 🚧 If using a third party speech-to-text transcription provider
>
> You must add the third-party speech-to-text transcription provider's API key in the Recall.ai dashboard. Follow your speech-to-text provider's setup guide before enabling transcription:
>
> * [ElevenLabs](https://docs.recall.ai/docs/elevenlabs)
> * [Deepgram](https://docs.recall.ai/docs/deepgram)
> * [AssemblyAI](https://docs.recall.ai/docs/assemblyai)
> * [AWS Transcribe](https://docs.recall.ai/docs/aws-transcribe)
> * [Rev](https://docs.recall.ai/docs/rev)
> * [Speechmatics](https://docs.recall.ai/docs/speechmatics)
> * [Gladia](https://docs.recall.ai/docs/gladia)
> * [Google Cloud Speech-to-Text](https://docs.recall.ai/docs/google-cloud-speech-to-text)
> * [Grok (xAI)](https://docs.recall.ai/docs/grok-xai)
> * [Soniox](https://docs.recall.ai/docs/soniox)

<br />

# Implementation guide

To implement post-meeting transcription correctly, first create a recording artifact using the <Anchor label="Meeting Bots API" target="_blank" href="doc:quickstart">Meeting Bots API</Anchor> or the <Anchor label="Desktop Recording SDK" target="_blank" href="doc:desktop-sdk">Desktop Recording SDK</Anchor>. After that point, you can create a transcript for the recording by:

1. Wait for the `recording.done` webhook event, which is triggered after the meeting has ended and the recording is available.
2. Call the <Anchor label="Create Async Transcript" target="_blank" href="https://docs.recall.ai/reference/recording_create_transcript_create">Create Async Transcript</Anchor> endpoint for that recording, configuring a transcription provider.
3. Wait for the `transcript.done` or `transcript.failed` webhook event to know when the transcript job has completed and then query the result, found on the transcript artifact.

> ❗️ Requirements for a reliable integration
>
> * **Schedule bots in advance whenever possible** - Creating bots at the last minute increases the chance of `507` errors. See the [Creating and scheduling bots](https://docs.recall.ai/docs/creating-and-scheduling-bots) guide for more details.
>
> * **Retry [Create Bot](https://docs.recall.ai/reference/bot_create) requests that return `507` status codes** - Retry any `507` responses returned by the Create Bot request every 30 seconds, for up to 10 attempts. Otherwise, a bot will not be created.
>
> * **Process webhook work asynchronously** - Acknowledge Recall webhook requests quickly, then handle downstream work asynchronously. Otherwise, the request may time out and Recall may retry it.

## Step 1: Verify the `recording.done` webhook event

Recall will notify your application when a recording is ready to be transcribed by sending a `recording.done` webhook event to the endpoint configured in the Recall dashboard. Before processing the event, your application must verify the request signature using your workspace verification secret.

Recall signs webhook and WebSocket upgrade requests using your workspace verification secret. **Your endpoint must verify the request** using the <Anchor label="verification helper function" target="_blank" href="doc:authenticating-requests-from-recallai#function-to-verify-requests-from-recall">verification helper function</Anchor>. For implementation details, follow the <Anchor label="Verifying requests from Recall.ai" target="_blank" href="doc:authenticating-requests-from-recallai">Verifying requests from Recall.ai</Anchor> guide.

Do not call Create Async Transcript, enqueue work, store the payload, or perform any downstream processing until verification succeeds. If verification fails, return a non-2xx response and stop processing.

### Recording artifact status change webhook

You can receive a webhook notifying you when the `recording` artifact status changes (e.g., from `processing` to `done`).

```json
{
  "event": string,
  "data": {
    "data": {
      "code": string,
      "sub_code": string | null,
      "updated_at": string // ISO86001
    },
    "recording": {
      "id": string,
      "metadata": object
    },
    "bot": {
      "id": string,
      "metadata": object
    }
  }
}
```

You must explicitly subscribe to each `event` you want to receive from the dashboard, as defined in the table below.

#### Recording artifact webhook events and codes

| Event                  | Code         | Description                                                                                                      |
| :--------------------- | :----------- | :--------------------------------------------------------------------------------------------------------------- |
| `recording.processing` | `processing` | The recording has started                                                                                        |
| `recording.done`       | `done`       | The recording has successfully completed. All data for media objects on the recording is now available           |
| `recording.failed`     | `failed`     | The recording failed to be captured. The `data.data.sub_code` will contain machine readable code for the failure |
| `recording.deleted`    | `deleted`    | The recording has been deleted from Recall systems.                                                              |

## Step 2: Start a transcription job

After your application receives and verifies a `recording.done` event for a recording, call the <Anchor label="Create Async Transcript" target="_blank" href="ref:recording_create_transcript_create">Create Async Transcript</Anchor> endpoint for that recording. You can get the recording ID via the recording artifact webhook's `data.recording.id` path on the webhook request body (as seen in the <Anchor label="Recording artifact status change webhook schema" target="_blank" href="#recording-artifact-status-change-webhook">Recording artifact status change webhook schema</Anchor>).

For example, the following request will create a transcript using the Recall.ai post-meeting transcription provider.

```curl
curl --request POST \
     --url https://RECALL_REGION.recall.ai/api/v1/recording/{RECORDING_ID}/create_transcript/ \
     --header "Authorization: RECALLAI_API_KEY" \
     --header "accept: application/json" \
     --header "content-type: application/json" \
     --data '
{
  "provider": {
    "recallai_async": {
      "language_code": "auto"
    }
  },
  "diarization": {
    "use_separate_streams_when_available": true,
  }
}
'
```

For the full list of provider-specific options, see the [Create Async Transcript](https://docs.recall.ai/reference/recording_create_transcript_create) API reference.

## Step 3: Receive and verify the transcript status webhook

Recall will notify your application when the post-meeting transcription job completes by sending either a `transcript.done` or `transcript.failed` webhook event to the webhook endpoint configured in your Recall dashboard.

You can reuse the same webhook endpoint that received the `recording.done` event, as long as that endpoint is also subscribed to `transcript.done` and `transcript.failed` and verifies incoming webhook requests before processing them.

Do not query the transcript result, retry transcription, update internal state, or perform any downstream processing until verification succeeds. If verification fails, return a non-2xx response and stop processing.

After verification succeeds, inspect the event type to determine the transcription job outcome:

* `transcript.done` - The transcript was created successfully and is available to query. The result is available from the transcript artifact's download URL.
* `transcript.failed` - The transcription provider failed to generate a transcript for the recording. More details are available in the transcript artifact's status.

## Step 4: Query and process the result of the verified transcription job

After receiving and verifying a `transcript.done` or `transcript.failed` webhook event, query the transcript artifact's download URL to retrieve the transcription result. You must return a 2xx response immediately and process all work asynchronously.

### Transcript artifact status change webhook

You can receive a webhook notifying you when the `transcript` artifact status changes (e.g., from `processing` to `done`))

```json
{
  "event": string,
  "data": {
    "data": {
      "code": string,
      "sub_code": string | null,
      "updated_at": string // ISO86001
    },
    "transcript": {
      "id": string,
      "metadata": object,
    },
    "recording": {
      "id": string,
      "metadata": object
    },
    "bot": {
      "id": string,
      "metadata": object
    }
  }
}
```

You must explicitly subscribe to each `event` you want to receive from the webhooks dashboard, as defined in the table below.

#### Transcript artifact webhook events and codes

| Event                   | Code         | Description                                                                                                                                     |
| :---------------------- | :----------- | :---------------------------------------------------------------------------------------------------------------------------------------------- |
| `transcript.processing` | `processing` | The media object has started capturing                                                                                                          |
| `transcript.done`       | `done`       | The media object has successfully completed. All data for media objects on the recording is now available                                       |
| `transcript.failed`     | `failed`     | The media object failed to be captured. The `data.sub_code` will contain machine readable code for the failure. See below for list of sub codes |
| `transcript.deleted`    | `deleted`    | The media object has been deleted from Recall systems.                                                                                          |

#### Transcript artifact webhook sub codes

Below are a list of `sub_code` that can be found on a `transcript.failed` webhook event.

| Sub Code                              | Reason                                                                                                                                                                                                                                                                                                          |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `provider_connection_failed`          | Recall is not able to connect to the 3rd party transcription provider. Common reasons for these include: *Insufficient funds in the transcription provider account for which the API key is provided* Using paid features on a free account \* Temporary service unavailability from the transcription provider |
| `zoom_global_captions_disabled`       | Meeting captions are disabled by the Zoom account                                                                                                                                                                                                                                                               |
| `zoom_host_disabled_meeting_captions` | The host of Zoom meeting has disabled meeting captions                                                                                                                                                                                                                                                          |
| `zoom_captions_failure`               | There was an error in enabling meeting captions for the Zoom call                                                                                                                                                                                                                                               |

### Case 1: The transcript was created successfully

In this case, the transcript was successfully created and is available for you to query so Recall sent you a `transcript.done` <Anchor label="transcript artifact status change webhook event" target="_blank" href="doc:asynchronous-transcription#transcript-artifact-status-change-webhook">transcript artifact status change webhook event</Anchor>. You can get the transcript ID from the webhook event at `data.transcript.id` and call the <Anchor label="Retrieve Transcript" target="_blank" href="ref:transcript_retrieve">Retrieve Transcript</Anchor> endpoint like so:

```curl
curl --request GET \
     --url https://RECALL_REGION.recall.ai/api/v1/transcript/{TRANSCRIPT_ID}/ \
     --header "Authorization: RECALLAI_API_KEY" \
     --header "accept: application/json"
```

The response schema can be found in the <Anchor label="Retrieve Transcript" target="_blank" href="ref:transcript_retrieve">Retrieve Transcript</Anchor> API reference. The response payload will contain the `data.download_url` field which you can use to query the transcript that was created for this recording.

#### Transcript download url data schema

The resulting data from querying the `data.download_url` will be returned as follows:

```json
[
  {
    "participant": {
      "id": number, // Id of the participant in the meeting. This id is not unique across meetings.
      "name": string | null, // Display name of the participant.
      "is_host": boolean | null, // Whether the participant is the host of the meeting.
      "platform": string | null, // Meeting platform constant
      "extra_data": json | null, // Extra data about the participant from the meeting platform.
      "email": string | null, // Email, if participant identification is turned on
    },
    "language_code": str, // The language code from the transcription provider, normalized to BCP-47.
                          // The simple code is .split('-')[0], and beware that some languages require
                          // 3-character codes (e.g. yue and haw)
    "words": [
      {
        "text": string, // The text of the word.
        "start_timestamp": {
          "absolute": string, // ISO 8601, will return null for async transcription
          "relative": number // seconds
        },
        "end_timestamp": {
          "absolute": string, // ISO 8601, will return null for async transcription
          "relative": number // seconds
        }
      }
    ]
  }
]
```

### Case 2: The transcript failed to generate

In this case, the transcription provider failed to generate a transcript so Recall sent you a `transcript.failed` event. You can get the machine-readable code from the `data.status.sub_code` field of the `transcript.failed` webhook event.

<Callout icon="❗️" theme="error">
  #### If the transcription job fails, you can retry the transcription with a backup transcription provider.
</Callout>

You can also check the bot logs in the dashboard to see why it failed.

![](https://files.readme.io/5f5436e6de1fa12061f3689785f59570a178d9c3b915cc6d9b71349865d5f16e-CleanShot_2025-11-23_at_13.11.202x.png)

If post-meeting transcription fails, you can retry the transcription with a backup transcription provider

<br />

# Additional transcription configurations

## Improving diarization and speaker attribution to transcript utterances

For the best diarization with speaker names, you should use <Anchor label="Perfect Diarization" target="_blank" href="doc:perfect-diarization">Perfect Diarization</Anchor> by setting `diarization.use_separate_streams_when_available: true` in the <Anchor label="Create Async Transcript" target="_blank" href="ref:recording_create_transcript_create">Create Async Transcript</Anchor> request.

For the best diarization when multiple participants are speaking from the same device, you can also use <Anchor label="Hybrid Diarization" target="_blank" href="doc:diarization#hybrid-diarization">Hybrid Diarization</Anchor> which is a combination of Perfect Diarization and <Anchor label="Machine Diarization" target="_blank" href="doc:diarization#machine-diarization">Machine Diarization</Anchor>.

To see all diarization configurations, see the <Anchor label="diarization guide" target="_blank" href="doc:diarization">diarization guide</Anchor>.

> 📘 Perfect diarization transcription cost
>
> Using `diarization.use_separate_streams_when_available: true` can increase transcription cost when participants speak concurrently or when background conversation is present, although this usually affects only a small portion of the total recording.

## Language detection for post-meeting transcription

Most of the third-party transcription providers that we integrate with support language detection. For more details of code switching see <Anchor label="Multilingual Transcription" target="_blank" href="doc:multilingual-transcription#multilingual-transcription-for-async-transcription">Multilingual Transcription</Anchor>.

## Accessing provider-specific fields from the speech-to-text transcription provider

<Callout icon="❗️" theme="error">
  Raw transcription provider data is not exposed for Recall.ai transcription or when `diarization.use_separate_streams_when_available: true`
</Callout>

If you want to extract a specific field from your transcription provider that is not exposed through the transcript generated by Recall then you can fetch the raw provider transcription response by:

* Fetching the transcript artifact via the <Anchor label="Retrieve Transcript" target="_blank" href="ref:transcript_retrieve">Retrieve Transcript</Anchor> endpoint
* The response payload will contain the `data.provider_data_download_url` field which you can use to query the transcript that was created for this recording.

The response of the `provider_data_download_url` varies by provider.

## Convert the transcript to a sentence-by-sentence transcript

You can convert the transcript JSON to a more human-readable transcript with <Anchor label="the following function" target="_blank" href="https://github.com/recallai/sample-apps/blob/main/bot_async_transcription/src/convert_to_readable_transcript.ts">the following function</Anchor>.

<br />

# FAQs

### How long does it take to transcribe a recording using post-meeting transcription?

The time to generate a transcript varies  on recording length and the transcription provider chosen. You will need to refer to their docs for info on this.

As a benchmark - a 1 hour recording takes about 1 minute to transcribe when using [Recall.ai Transcription](https://docs.recall.ai/docs/recallai-transcription)(mixed audio regardless of language specified).

### How to get the transcript summary?

To get the transcript summary, you will need to pass the transcript to a third-party LLM to analyze. Recall doesn't support transcription summaries out of the box.

### What are the supported post-meeting transcription providers

| Speech-to-text provider                         | Async transcription (meeting bots + desktop recording sdk) | Provider field name in Create Async Transcript |
| :---------------------------------------------- | :--------------------------------------------------------- | :--------------------------------------------- |
| Recall.ai                                       | ✅ Yes                                                      | `recallai_async`                               |
| Eleven Labs                                     | ✅ Yes                                                      | `elevenlabs_async`                             |
| Deepgram                                        | ✅ Yes                                                      | `deepgram_async`                               |
| Assembly AI                                     | ✅ Yes                                                      | `assembly_ai_async`                            |
| AWS Transcribe                                  | ✅ Yes                                                      | `aws_transcribe_async`                         |
| Rev                                             | ✅ Yes                                                      | `rev_async`                                    |
| Speechmatics                                    | ✅ Yes                                                      | `speechmatics_async`                           |
| Gladia                                          | ✅ Yes                                                      | `gladia_v2_async`                              |
| Google Cloud STT                                | ✅ Yes                                                      | `google_speech_v2_async`                       |
| [Soniox](https://docs.recall.ai/docs/soniox#post-meeting-transcription) | ✅ Yes                                                      | `soniox_async`                                 |

You can view the full list of supported fields for each of the providers in the [Create Async Transcript](https://docs.recall.ai/reference/recording_create_transcript_create) endpoint under the `provider` body params.

## How many transcripts can I generate for a recording?

To prevent accidental loops from creating excessive transcripts for the same recording (which could incurs usage costs with the transcription provider), a given recording can have up to 10 succesful transcripts at one time, up to 100 attempted.

If you try to create new transcripts beyond these limits, then the API will return a 400 and you will need to delete existing transcripts by calling the [Delete Transcript](https://docs.recall.ai/reference/transcript_destroy) API endpoint before creating a new one. This is to protect developers form unexpected/accidental runaway transcription usage