Name: ElevenLabs Scribe v2 API: Speech to Text in 90+ Languages
Brand: magicapi
SKU: api-magicapi-speech-to-text-api-multilingual-elevenlabs-scribe-v2
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎙️ Speech-to-Text Transcription API (ElevenLabs Scribe v2)

## Overview
Scribe v2 is a speech-to-text model from ElevenLabs. Its developer describes it as supporting 90+ languages, word-level timestamps, speaker diarization for up to 32 speakers, audio event tagging and keyterm biasing, for files up to 3 GB and 10 hours long.

Send the URL of an audio or video file in `audio`. The result is a JSON object with the full transcript in `text`, the detected `language_code` and `language_probability`, the `duration_seconds` of the audio and a `words` list with start and end times for each word and space.

## Features
- **Audio and video files**: MP3, WAV, M4A, FLAC, OGG, OPUS, WebM, AAC, MP4, MOV, MKV, AVI and more, up to 3 GB and 10 hours.
- **Language detection**: `language_code` is `auto` by default. Set an ISO-639-1 (`en`) or ISO-639-3 (`eng`) code to fix the language, which can help with noisy or unusual audio.
- **Speaker diarization**: set `diarize` to `true` to label up to 32 speakers; each word then carries a `speaker_id`. `num_speakers` (0 to 32, `0` lets the model decide) sets the maximum number of speakers expected.
- **Timestamps**: `timestamps_granularity` is `word` (default), `character` (adds per-character timing) or `none`.
- **Audio event tags**: `tag_audio_events` (default `true`) marks non-speech sounds such as (laughter), (footsteps) or (applause).
- **Clean transcripts**: `no_verbatim` removes filler words such as 'um' and 'uh', false starts and disfluencies.
- **Keyterms**: bias the transcript toward product names, technical terms or proper nouns with a comma-separated `keyterms` list (up to 1000 terms, 50 characters each).
- **Sampling**: `temperature` (-1 to 2, `-1` uses the model default) and `seed` (-1 to 2147483647, `-1` for a non-deterministic seed).

## Use Cases
1. **Meeting and interview transcripts**: turn recordings into text with each speaker labelled.
2. **Subtitles and captions**: build caption timing from the per-word `start` and `end` times.
3. **Searchable media archives**: index podcasts, lectures and videos by their transcript text.
4. **Domain vocabulary**: transcribe calls or talks full of product names and jargon with `keyterms`.

## Visual Examples
### Example Input
The example sends a 60-second English audiobook recording in `audio` and leaves every other field at its default (`language_code` `auto`, `diarize` `false`, `timestamps_granularity` `word`, `tag_audio_events` `true`).

[Listen to the example input](https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3)

### Example Output
The model detected English (`eng`, probability 0.97) for 60 seconds of audio. The `words` list had 225 entries (words and spaces); the first three are shown here.

```json
{
  "duration_seconds": 60,
  "language_code": "eng",
  "language_probability": 0.9687974452972412,
  "text": "Section zero of Personal Memoirs of U.S. Grant. This is a LibriVox recording. All LibriVox recordings are in the public domain. For more information or to volunteer, please visit LibriVox.org. Recording by Jim Clevenger. Personal Memoirs of U.S. Grant by Ulysses S. Grant. Preface. Man proposes and God disposes. There are but few important events in the affairs of men brought about by their own choice. Although frequently urged by friends to write my memoirs, I had determined never to do so nor to write anything for publication. At the age of nearly sixty-two, I received an injury from a fall which confined me closely to the house while it did not apparently",
  "words": [
    {
      "end": 0.78,
      "speaker_id": null,
      "start": 0.3,
      "text": "Section",
      "type": "word"
    },
    {
      "end": 0.96,
      "speaker_id": null,
      "start": 0.78,
      "text": " ",
      "type": "spacing"
    },
    {
      "end": 1.44,
      "speaker_id": null,
      "start": 0.96,
      "text": "zero",
      "type": "word"
    }
  ]
}
```

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `audio` | string (URL) | Yes |  |  | Audio or video file URL to transcribe. Supports MP3, WAV, M4A, FLAC, OGG, OPUS, WebM, AAC, MP4, MOV, MKV, AVI and more. Max 3 GB, up to 10 hours. |
| `language_code` | string | No | `auto` |  | Language of the audio as an ISO-639-1 (e.g. 'en') or ISO-639-3 (e.g. 'eng') code. Set to 'auto' to detect the language automatically. Setting a specific language can improve accuracy for noisy or unusual audio. |
| `diarize` | boolean | No | `false` |  | Identify and label different speakers in the audio. When enabled, each word in the output includes a 'speaker_id'. Supports up to 32 speakers. |
| `num_speakers` | integer | No | `0` | `0` to `32` | Maximum number of speakers expected in the audio. Helps the model with diarization. Set to 0 to let the model decide. Only used when 'diarize' is true. |
| `timestamps_granularity` | string | No | `word` | `none`, `word`, `character` | Granularity of timestamps in the output: `word` returns start and end times for each word, `character` adds per-character timing, `none` omits timestamps. |
| `tag_audio_events` | boolean | No | `true` |  | Tag non-speech sounds in the transcription, like (laughter), (footsteps), or (applause). |
| `no_verbatim` | boolean | No | `false` |  | Remove filler words ('um', 'uh'), false starts, and disfluencies from the transcript. Produces a cleaner, more readable output. |
| `keyterms` | string | No | `""` |  | Comma-separated list of words or phrases to bias the transcript towards, such as product names, technical terms or proper nouns. Up to 1000 terms, max 50 characters each. |
| `temperature` | number | No | `-1` | `-1` to `2` | Sampling temperature. Higher values produce more diverse, less deterministic output. Set to -1 to use the model default (usually 0). |
| `seed` | integer | No | `-1` | `-1` to `2147483647` | Random seed for reproducible outputs. Set to -1 to use a non-deterministic seed. |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0046 per API unit.
- **1 API unit = 1 started minute of input audio**, as measured by the model for each request. One hour of audio is 60 units ($0.276).
- A 90-second file counts as 2 units ($0.0092). Diarization, timestamps, keyterms and the other settings do not change the price.
- **Example cost**: the 60-second example was measured as 1 minute: 1 API unit = **$0.0046**.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/speech-to-text-api-multilingual-elevenlabs-scribe-v2`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/speech-to-text-api-multilingual-elevenlabs-scribe-v2/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
      "version": "elevenlabs/scribe-v2",
      "input": {
        "audio": "https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3"
      }
    }'
```

Response (201 Created):
```json
{
  "id": "0r25eej5c9rmy0d1c6ws9mb0ym",
  "version": "elevenlabs/scribe-v2",
  "status": "starting",
  "created_at": "2026-10-22T03:48:14.499Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/speech-to-text-api-multilingual-elevenlabs-scribe-v2/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "0r25eej5c9rmy0d1c6ws9mb0ym",
  "status": "succeeded",
  "output": {
    "duration_seconds": 60,
    "language_code": "eng",
    "language_probability": 0.9687974452972412,
    "text": "Section zero of Personal Memoirs of U.S. Grant. This is a LibriVox recording. All LibriVox recordings are in the public domain. For more information or to volunteer, please visit LibriVox.org. Recording by Jim Clevenger. Personal Memoirs of U.S. Grant by Ulysses S. Grant. Preface. Man proposes and God disposes. There are but few important events in the affairs of men brought about by their own choice. Although frequently urged by friends to write my memoirs, I had determined never to do so nor to write anything for publication. At the age of nearly sixty-two, I received an injury from a fall which confined me closely to the house while it did not apparently",
    "words": [
      {
        "end": 0.78,
        "speaker_id": null,
        "start": 0.3,
        "text": "Section",
        "type": "word"
      },
      {
        "end": 0.96,
        "speaker_id": null,
        "start": 0.78,
        "text": " ",
        "type": "spacing"
      },
      {
        "end": 1.44,
        "speaker_id": null,
        "start": 0.96,
        "text": "zero",
        "type": "word"
      }
    ]
  },
  "error": null,
  "created_at": "2026-10-22T03:48:14.499Z",
  "started_at": "2026-10-22T03:48:14.512Z",
  "completed_at": "2026-10-22T03:48:16.196Z"
}
```

`output` is a JSON object with `text` (the full transcript), `language_code`, `language_probability`, `duration_seconds` and `words`. Each entry in `words` has `text`, `type` (for example `word` or `spacing`), `start` and `end` in seconds and `speaker_id`, which is set when `diarize` is `true`. The `words` list above is shortened to its first 3 entries.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `audio`, a `timestamps_granularity` that is not `none`, `word` or `character`, or `num_speakers` above 32.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/speech-to-text-api-multilingual-elevenlabs-scribe-v2";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "elevenlabs/scribe-v2", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
    "audio": "https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3"
  }).then((output) => console.log(output.text));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/speech-to-text-api-multilingual-elevenlabs-scribe-v2"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "elevenlabs/scribe-v2", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


output = create_and_wait_for_prediction({
    "audio": "https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3"
})
print(output["text"])
```

## FAQ
- **Which languages does it transcribe?**
  - Its developer lists 90+ languages. Leave `language_code` at `auto` to detect the language, or set a code such as `en` or `eng`. The detected code and its probability are returned in `language_code` and `language_probability`.
- **How do I tell speakers apart?**
  - Set `diarize` to `true`. Each entry in `words` then includes a `speaker_id`. If you know how many people speak, set `num_speakers` (up to 32).
- **Can I send a video file?**
  - Yes. `audio` accepts video files such as MP4, MOV, MKV and AVI as well as audio files, up to 3 GB and 10 hours.
- **How much does a transcript cost?**
  - $0.0046 per started minute of audio, so one hour costs $0.276. The 60-second example cost $0.0046.
- **How do I get a cleaner transcript?**
  - Set `no_verbatim` to `true` to drop filler words and false starts, and `tag_audio_events` to `false` to leave out tags such as (laughter).
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page. You can also email our support team at hello@magicapi.com.


Transcribe audio and video with ElevenLabs Scribe v2: 90+ languages, word-level timestamps, speaker diarization for up to 32 speakers and keyterm biasing.