bytedance/seed-asr-2.0

audio-to-text

Seed ASR 2.0 API by ByteDance

bytedance/seed-asr-2.0

Seed-asr-2.0

BytePlus Seed Speech recording-file recognition (ASR 2.0): transcribe an audio file to text with punctuation, ITN, sentence segmentation, speaker diarization, and 51-language support.

Seed ASR 2.0 is developed by ByteDance. Atlas Cloud (operated by Atlas Cloud AI LLC) provides access to it and does not own it. All trademarks belong to their respective owners.

INPUT

Audio url *

You can drag and drop a file or click to upload

MAX:1

Format

Language

Enable itn

Enable punc

Enable ddc

Enable speaker info

Additional Settings

OUTPUT

Idle

Ever wondered how to get that flawless glow? Introducing our new skincare line designed for real life.

Parameters

Code Example
import requests
import time

# Step 1: Start audio generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateAudio"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "bytedance/seed-asr-2.0",  # Required. model name
    "audio_url": "example_value",  # Required. URL of the audio file to transcribe
    "format": "mp3",  # Audio container format. options: mp3 | wav | ogg | raw
    "language": "example_value",  # Optional language code
    "enable_itn": True,  # Inverse text normalization (e
    "enable_punc": False,  # Add punctuation to the transcript
    "enable_ddc": False,  # Semantic smoothing (remove fillers/repeats)
    "enable_speaker_info": False,  # Speaker diarization (<=10 speakers)
    "show_utterances": False,  # Return per-sentence segments with timestamps
    "boosting_table_name": "example_value",  # Hotword table name to boost recognition of listed terms (e
    "correct_table_name": "example_value",  # Correction table name: post-recognition forced replacement (wrong→right pairs)
    "context": "example_value",  # Inline hotwords, no table needed
}

generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]

# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"

def check_status():
    while True:
        response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
        result = response.json()

        if result["data"]["status"] in ["completed", "succeeded"]:
            print("Generated audio:", result["data"]["outputs"][0])
            return result["data"]["outputs"][0]
        elif result["data"]["status"] == "failed":
            raise Exception(result["data"]["error"] or "Generation failed")
        else:
            # Still processing, wait 2 seconds
            time.sleep(2)

audio_url = check_status()

Install

Install the required package for your language.

pip install requests

Authentication

All API requests require authentication via an API key. You can get your API key from the Atlas Cloud dashboard.

export ATLASCLOUD_API_KEY="your-api-key-here"

HTTP Headers

import os

API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

Keep your API key secure

Never expose your API key in client-side code or public repositories. Use environment variables or a backend proxy instead.

Submit a request

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateAudio"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "your-model",
    "text": "Hello, welcome to AtlasCloud text-to-speech."
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Submit a Request

Submit an asynchronous generation request. The API returns a prediction ID that you can use to check the status and retrieve the result.

POST/api/v1/model/generateAudio

Request Body

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateAudio"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}

data = {
    "model": "bytedance/seed-asr-2.0",
    "text": "Hello, welcome to AtlasCloud text-to-speech."
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

print(f"Prediction ID: {result['data']['id']}")
print(f"Status: {result['data']['status']}")

Response

{
  "code": 200,
  "data": {
    "id": "pred_abc123",
    "status": "processing",
    "model": "model-name",
    "created_at": "2025-01-01T00:00:00Z"
  }
}

Check Status

Poll the prediction endpoint to check the current status of your request.

GET/api/v1/model/prediction/{prediction_id}

Polling Example

import requests
import time

prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

while True:
    response = requests.get(url, headers=headers)
    result = response.json()
    status = result["data"]["status"]
    print(f"Status: {status}")

    if status in ["completed", "succeeded"]:
        output_url = result["data"]["outputs"][0]
        print(f"Output URL: {output_url}")
        break
    elif status == "failed":
        print(f"Error: {result['data'].get('error', 'Unknown')}")
        break

    time.sleep(3)

Status Values

processingThe request is still being processed.

completedGeneration is complete. Outputs are available.

succeededGeneration succeeded. Outputs are available.

failedGeneration failed. Check the error field.

Completed Response

{
  "data": {
    "id": "pred_abc123",
    "status": "completed",
    "outputs": [
      "https://storage.atlascloud.ai/outputs/result.mp3"
    ],
    "metrics": {
      "predict_time": 8.3
    },
    "created_at": "2025-01-01T00:00:00Z",
    "completed_at": "2025-01-01T00:00:10Z"
  }
}

Input Schema

The following parameters are accepted in the request body.

Total: 12Required: 2Optional: 10

modelstringrequired

model name

Default: "bytedance/seed-asr-2.0"

audio_urlstringrequired

URL of the audio file to transcribe. Public URL or Base64. Formats: wav/mp3/ogg/raw. Max ~512MB.

formatstring

Audio container format.

Default: "mp3"

mp3wavoggraw

languagestring

Optional language code. Leave empty to auto-recognize Chinese/English/dialects. Or set a code, e.g. en-US, zh-CN, yue-CN, ja-JP, es-MX (51 languages supported).

enable_itnboolean

Inverse text normalization (e.g. 'one hundred' -> '100').

Default: true

enable_puncboolean

Add punctuation to the transcript.

Default: false

enable_ddcboolean

Semantic smoothing (remove fillers/repeats).

Default: false

enable_speaker_infoboolean

Speaker diarization (<=10 speakers).

Default: false

show_utterancesboolean

Return per-sentence segments with timestamps.

Default: false

boosting_table_namestring

Hotword table name to boost recognition of listed terms (e.g. product names). Tables are provisioned server-side by Atlas — contact us with your word list to get a table name. NOTE: a nonexistent table name is silently ignored (the task still succeeds).

correct_table_namestring

Correction table name: post-recognition forced replacement (wrong→right pairs). Provisioned server-side by Atlas, same as boosting_table_name. A nonexistent table name is silently ignored.

contextstring

Inline hotwords, no table needed. Must be a JSON STRING of the form {"hotwords":[{"word":"YourTerm"}]}. WARNING: plain non-JSON text makes the task FAIL; unrecognized JSON keys are silently ignored.

Example Request Body

{
  "model": "bytedance/seed-asr-2.0",
  "audio_url": "example_audio_url",
  "format": "mp3",
  "enable_itn": true,
  "enable_punc": false,
  "enable_ddc": false,
  "enable_speaker_info": false,
  "show_utterances": false
}

Output Schema

The API returns a prediction response with the generated output URLs.

modelstring

model name

Default: "bytedance/seed-asr-2.0"

created_atstring

ISO timestamp of when the request was created.

idstring

Unique identifier for the prediction.

outputsarray

Array with the recognized transcript text (outputs[0]).

statusstring

Status: created, processing, completed, or failed.

stt_resultobject

Structured transcription result: text, duration (seconds), and words[] with per-word timestamps when show_utterances=true.

Example Response

{
  "id": "pred_abc123",
  "status": "completed",
  "model": "model-name",
  "outputs": [
    "https://storage.atlascloud.ai/outputs/result.png"
  ],
  "metrics": {
    "predict_time": 8.3
  },
  "created_at": "2025-01-01T00:00:00Z",
  "completed_at": "2025-01-01T00:00:10Z"
}

Atlas Cloud Skills

Atlas Cloud Skills integrates 400+ AI models directly into your AI coding assistant. One command to install, then use natural language to generate images, videos, and chat with LLMs.

Supported Clients

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ supported clients

Install

npx skills add AtlasCloudAI/atlas-cloud-skills

Setup API Key

Get your API key from the Atlas Cloud dashboard and set it as an environment variable.

export ATLASCLOUD_API_KEY="your-api-key-here"

Capabilities

Once installed, you can use natural language in your AI assistant to access all Atlas Cloud models.

Image GenerationGenerate images with models like Nano Banana 2, Z-Image, and more.

Video CreationCreate videos from text or images with Kling, Vidu, Veo, etc.

LLM ChatChat with Qwen, DeepSeek, and other large language models.

Media UploadUpload local files for image editing and image-to-video workflows.

Learn more

github.com/AtlasCloudAI/atlas-cloud-skills

MCP Server

Atlas Cloud MCP Server connects your IDE with 400+ AI models via the Model Context Protocol. Works with any MCP-compatible client.

Supported Clients

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ supported clients

Install

npx -y atlascloud-mcp

Configuration

Add the following configuration to your IDE's MCP settings file.

{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": [
        "-y",
        "atlascloud-mcp"
      ],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}

Available Tools

atlas_generate_imageGenerate images from text prompts.

atlas_generate_videoCreate videos from text or images.

atlas_chatChat with large language models.

atlas_list_modelsBrowse 400+ available AI models.

atlas_quick_generateOne-step content creation with auto model selection.

atlas_upload_mediaUpload local files for API workflows.

Learn more

github.com/AtlasCloudAI/mcp-server

API Schema

{
  "info": {
    "description": "The AtlasCloud API.",
    "title": "AtlasCloud API",
    "version": "1.0.0"
  },
  "paths": {
    "/api/v1/model/generateAudio": {
      "post": {
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "The request status."
          }
        },
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Input"
              }
            }
          }
        }
      },
      "x-api-name": "model_run"
    },
    "/api/v1/model/prediction/{request_id}": {
      "get": {
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "Result of the request."
          }
        },
        "parameters": [
          {
            "in": "path",
            "name": "request_id",
            "schema": {
              "type": "string",
              "description": "Request ID"
            },
            "required": true
          }
        ]
      },
      "x-api-name": "model_result"
    }
  },
  "openapi": "3.0.0",
  "servers": [
    {
      "url": "https://api.atlascloud.ai"
    }
  ],
  "components": {
    "schemas": {
      "Input": {
        "properties": {
          "model": {
            "type": "string",
            "description": "model name",
            "default": "bytedance/seed-asr-2.0"
          },
          "audio_url": {
            "description": "URL of the audio file to transcribe. Public URL or Base64. Formats: wav/mp3/ogg/raw. Max ~512MB.",
            "type": "string",
            "x-ui-component": "uploaders"
          },
          "format": {
            "type": "string",
            "description": "Audio container format.",
            "default": "mp3",
            "enum": [
              "mp3",
              "wav",
              "ogg",
              "raw"
            ]
          },
          "language": {
            "description": "Optional language code. Leave empty to auto-recognize Chinese/English/dialects. Or set a code, e.g. en-US, zh-CN, yue-CN, ja-JP, es-MX (51 languages supported).",
            "type": "string"
          },
          "enable_itn": {
            "type": "boolean",
            "description": "Inverse text normalization (e.g. 'one hundred' -> '100').",
            "default": true
          },
          "enable_punc": {
            "type": "boolean",
            "description": "Add punctuation to the transcript.",
            "default": false
          },
          "enable_ddc": {
            "type": "boolean",
            "description": "Semantic smoothing (remove fillers/repeats).",
            "default": false
          },
          "enable_speaker_info": {
            "type": "boolean",
            "description": "Speaker diarization (<=10 speakers).",
            "default": false
          },
          "show_utterances": {
            "type": "boolean",
            "description": "Return per-sentence segments with timestamps.",
            "default": false
          },
          "boosting_table_name": {
            "type": "string",
            "description": "Hotword table name to boost recognition of listed terms (e.g. product names). Tables are provisioned server-side by Atlas — contact us with your word list to get a table name. NOTE: a nonexistent table name is silently ignored (the task still succeeds)."
          },
          "correct_table_name": {
            "type": "string",
            "description": "Correction table name: post-recognition forced replacement (wrong→right pairs). Provisioned server-side by Atlas, same as boosting_table_name. A nonexistent table name is silently ignored."
          },
          "context": {
            "type": "string",
            "description": "Inline hotwords, no table needed. Must be a JSON STRING of the form {\"hotwords\":[{\"word\":\"YourTerm\"}]}. WARNING: plain non-JSON text makes the task FAIL; unrecognized JSON keys are silently ignored."
          }
        },
        "required": [
          "model",
          "audio_url"
        ],
        "type": "object",
        "x-order-properties": [
          "model",
          "audio_url",
          "format",
          "language",
          "enable_itn",
          "enable_punc",
          "enable_ddc",
          "enable_speaker_info",
          "show_utterances",
          "context",
          "boosting_table_name",
          "correct_table_name"
        ]
      },
      "PredictionResponse": {
        "properties": {
          "model": {
            "type": "string",
            "description": "model name",
            "default": "bytedance/seed-asr-2.0"
          },
          "created_at": {
            "description": "ISO timestamp of when the request was created.",
            "format": "date-time",
            "type": "string"
          },
          "id": {
            "description": "Unique identifier for the prediction.",
            "type": "string"
          },
          "outputs": {
            "description": "Array with the recognized transcript text (outputs[0]).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "status": {
            "description": "Status: created, processing, completed, or failed.",
            "type": "string"
          },
          "urls": {
            "description": "Object containing related API endpoints.",
            "type": "object"
          },
          "stt_result": {
            "type": "object",
            "description": "Structured transcription result: text, duration (seconds), and words[] with per-word timestamps when show_utterances=true.",
            "properties": {
              "text": {
                "type": "string",
                "description": "Full transcript."
              },
              "duration": {
                "type": "number",
                "description": "Audio duration in seconds."
              },
              "words": {
                "type": "array",
                "description": "Word-level segments (show_utterances=true). Times in seconds.",
                "items": {
                  "type": "object",
                  "properties": {
                    "text": {
                      "type": "string"
                    },
                    "start": {
                      "type": "number"
                    },
                    "end": {
                      "type": "number"
                    },
                    "type": {
                      "type": "string",
                      "description": "word | utterance"
                    },
                    "speaker_id": {
                      "type": "string",
                      "description": "Present when enable_speaker_info=true."
                    }
                  }
                }
              }
            }
          }
        },
        "type": "object"
      }
    },
    "securitySchemes": {
      "apiKeyAuth": {
        "in": "header",
        "name": "Authorization",
        "type": "apiKey"
      }
    }
  }
}

LLM-Friendly Prompt Template

# bytedance/seed-asr-2.0

> BytePlus Seed Speech recording-file recognition (ASR 2.0): transcribe an audio file to text with punctuation, ITN, sentence segmentation, speaker diarization, and 51-language support.


## Overview

- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateAudio` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `bytedance/seed-asr-2.0`


## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:

- **`model`** (`string`, _required_):
  model name
  - Default: `"bytedance/seed-asr-2.0"`

- **`audio_url`** (`string`, _required_):
  URL of the audio file to transcribe. Public URL or Base64. Formats: wav/mp3/ogg/raw. Max ~512MB.

- **`format`** (`string`, _optional_):
  Audio container format.
  - Default: `"mp3"`
  - Options: "mp3", "wav", "ogg", "raw"

- **`language`** (`string`, _optional_):
  Optional language code. Leave empty to auto-recognize Chinese/English/dialects. Or set a code, e.g. en-US, zh-CN, yue-CN, ja-JP, es-MX (51 languages supported).

- **`enable_itn`** (`boolean`, _optional_):
  Inverse text normalization (e.g. 'one hundred' -> '100').
  - Default: `true`

- **`enable_punc`** (`boolean`, _optional_):
  Add punctuation to the transcript.
  - Default: `false`

- **`enable_ddc`** (`boolean`, _optional_):
  Semantic smoothing (remove fillers/repeats).
  - Default: `false`

- **`enable_speaker_info`** (`boolean`, _optional_):
  Speaker diarization (<=10 speakers).
  - Default: `false`

- **`show_utterances`** (`boolean`, _optional_):
  Return per-sentence segments with timestamps.
  - Default: `false`

- **`context`** (`string`, _optional_):
  Inline hotwords, no table needed. Must be a JSON STRING of the form {"hotwords":[{"word":"YourTerm"}]}. WARNING: plain non-JSON text makes the task FAIL; unrecognized JSON keys are silently ignored.

- **`boosting_table_name`** (`string`, _optional_):
  Hotword table name to boost recognition of listed terms (e.g. product names). Tables are provisioned server-side by Atlas — contact us with your word list to get a table name. NOTE: a nonexistent table name is silently ignored (the task still succeeds).

- **`correct_table_name`** (`string`, _optional_):
  Correction table name: post-recognition forced replacement (wrong→right pairs). Provisioned server-side by Atlas, same as boosting_table_name. A nonexistent table name is silently ignored.



**Required Parameters Example**:

```json
{
  "model": "bytedance/seed-asr-2.0",
  "audio_url": ""
}
```


**Full Example**:

```json
{
  "model": "bytedance/seed-asr-2.0",
  "audio_url": "",
  "format": "mp3",
  "language": "",
  "enable_itn": true,
  "enable_punc": false,
  "enable_ddc": false,
  "enable_speaker_info": false,
  "show_utterances": false,
  "context": "",
  "boosting_table_name": "",
  "correct_table_name": ""
}
```


### Output Schema

The API returns the following output format:


- **`model`** (`string`, _optional_):
  model name
  - Default: `"bytedance/seed-asr-2.0"`

- **`created_at`** (`string`, _optional_):
  ISO timestamp of when the request was created.

- **`id`** (`string`, _optional_):
  Unique identifier for the prediction.

- **`outputs`** (`array[string]`, _optional_):
  Array with the recognized transcript text (outputs[0]).

- **`status`** (`string`, _optional_):
  Status: created, processing, completed, or failed.

- **`urls`** (`object`, _optional_):
  Object containing related API endpoints.

- **`stt_result`** (`object`, _optional_):
  Structured transcription result: text, duration (seconds), and words[] with per-word timestamps when show_utterances=true.
  - Properties:
    - **`text`** (`string`, _optional_):
      Full transcript.

    - **`duration`** (`number`, _optional_):
      Audio duration in seconds.

    - **`words`** (`array[object]`, _optional_):
      Word-level segments (show_utterances=true). Times in seconds.
      - Item properties:
        - **`text`** (`string`, _optional_):

        - **`start`** (`number`, _optional_):

        - **`end`** (`number`, _optional_):

        - **`type`** (`string`, _optional_):
          word | utterance

        - **`speaker_id`** (`string`, _optional_):
          Present when enable_speaker_info=true.





**Example Response**:

```json
{
  "model": "bytedance/seed-asr-2.0",
  "created_at": "",
  "id": "",
  "outputs": [
    ""
  ],
  "status": "",
  "urls": {},
  "stt_result": {
    "text": "",
    "duration": 0,
    "words": [
      {
        "text": "",
        "start": 0,
        "end": 0,
        "type": "",
        "speaker_id": ""
      }
    ]
  }
}
```


## Usage Examples

### cURL

```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateAudio" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "bytedance/seed-asr-2.0",
  "audio_url": "",
  "format": "mp3",
  "language": "",
  "enable_itn": true,
  "enable_punc": false,
  "enable_ddc": false,
  "enable_speaker_info": false,
  "show_utterances": false,
  "context": "",
  "boosting_table_name": "",
  "correct_table_name": ""
}'

# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}

# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```

## Additional Resources

### Documentation

- [Model Playground](https://www.atlascloud.ai/models/bytedance/seed-asr-2.0)

Ever wondered how to get that flawless glow? Introducing our new skincare line designed for real life.

Seed ASR 2.0 (Recording-File Recognition)

Transcribe an audio file to text with punctuation, ITN, sentence segmentation, speaker diarization, and 51-language support.

🌟 Key Features

🗣 High-Accuracy Transcription

State-of-the-art recognition tuned for real-world recordings.

🌍 51 Languages

Auto-detects Chinese/English/dialects, or pin a language code.

🎯 Rich Output

Punctuation, inverse text normalization, per-word timestamps, speaker labels.

📻 Far-Field Optimized

Robust to meeting-room and call-center audio.

⚙️ Parameters

Parameter	Required	Description
`audio_url`*	✅	Audio file URL or Base64. Formats: wav/mp3/ogg/raw.
`format`	⬜	Audio format: `mp3` (default) / `wav` / `ogg` / `raw`.
`language`	⬜	Language code (e.g. `en-US`, `yue-CN`); empty = auto (CN/EN/dialects). 51 languages.
`enable_itn`	⬜	Inverse text normalization. Default `true`.
`enable_punc`	⬜	Add punctuation. Default `false`.
`enable_ddc`	⬜	Semantic smoothing. Default `false`.
`enable_speaker_info`	⬜	Speaker diarization. Default `false`.
`show_utterances`	⬜	Per-word timestamps in `stt_result.words`. Default `false`.
`context`	⬜	Inline hotwords — no table needed. JSON string: `{"hotwords":[{"word":"YourTerm"}]}`. See below.
`boosting_table_name`	⬜	Server-side hotword table name (provisioned by Atlas).
`correct_table_name`	⬜	Server-side correction table name (wrong→right replacement, provisioned by Atlas).

🔥 Hotwords & Correction

Two ways to improve recognition of product names, people, and domain terms:

1. Inline via context (recommended — self-service, per request):

{
  "audio_url": "https://…/meeting.mp3",
  "context": "{\"hotwords\":[{\"word\":\"Zylophex\"},{\"word\":\"AtlasCloud\"}]}"
}

⚠️ context must be a JSON string exactly as above. Plain text (non-JSON) makes the task fail; unrecognized JSON keys are silently ignored.

2. Server-side tables via boosting_table_name / correct_table_name: for large or stable word lists. Tables live in the service account — send Atlas your word list and we provision the table and hand back its name. ⚠️ A nonexistent table name is silently ignored (the task still succeeds), so use the exact name we give you.

📤 Output

outputs[0] contains the recognized transcript text. stt_result carries the structured result: text, duration (seconds), and — with show_utterances=true — words[] with per-word start/end timestamps in seconds (plus speaker_id when diarization is on).

🎯 Use Cases

Meeting & Interview Transcription — turn recordings into searchable text.
Media Subtitling — transcribe podcasts/videos with timestamps.
Voice Analytics — call-center QA, speaker diarization.
Multilingual Content — transcribe across 51 languages.

Explore Similar Models

NEW

text-to-audio

Seed Audio 1.0

Doubao‑Audio‑Generate‑1.0 is Doubao Voice’s next‑generation audio‑generation engine. The industry‑first commercial tool creates film‑grade audio with just one prompt. It eliminates cumbersome audio‑engineering work. Creators generate publish‑ready radio dramas, podcasts and branded audio easily, shifting from a simple voice‑generator to an AI audio director. It serves audiobooks, serialized episodes and commercial audio for high‑quality narrative‑driven production.

xAI TTS v1

xAI TTS v1 is a high-fidelity text-to-speech model that converts text into natural, expressive speech with sub-second latency, supporting 20 languages and 80+ voices with fine-grained delivery control.

ElevenLabs v3 Text-to-Speech

ElevenLabs v3 Text-to-Speech model. High-quality speech generation from text prompts.

Suno chirp-v4-5-all

Suno text-to-music via APIMart: inspiration mode (custom=false) turns a description into a song; custom mode (custom=true) uses your own lyrics. Async; returns 2 tracks per generation.

Suno chirp-v4-5-plus

Suno text-to-music via APIMart: inspiration mode (custom=false) turns a description into a song; custom mode (custom=true) uses your own lyrics. Async; returns 2 tracks per generation.

Suno chirp-auk

Suno text-to-music via APIMart: inspiration mode (custom=false) turns a description into a song; custom mode (custom=true) uses your own lyrics. Async; returns 2 tracks per generation.

Suno chirp-fenix

Suno text-to-music via APIMart: inspiration mode (custom=false) turns a description into a song; custom mode (custom=true) uses your own lyrics. Async; returns 2 tracks per generation.

Suno chirp-v3-5

Suno text-to-music via APIMart: inspiration mode (custom=false) turns a description into a song; custom mode (custom=true) uses your own lyrics. Async; returns 2 tracks per generation.

Suno chirp-v4

Suno text-to-music via APIMart: inspiration mode (custom=false) turns a description into a song; custom mode (custom=true) uses your own lyrics. Async; returns 2 tracks per generation.

Suno chirp-v5

Suno text-to-music via APIMart: inspiration mode (custom=false) turns a description into a song; custom mode (custom=true) uses your own lyrics. Async; returns 2 tracks per generation.

MiniMax Music 2.6

MiniMax text-to-music (latest): generate a full vocal or instrumental song from a style prompt plus lyrics with [Verse]/[Chorus] structure tags. Synchronous single-call generation.

xAI STT v1

xAI STT v1 is a production-grade speech-to-text model that transcribes audio into accurate, formatted text. It supports 24+ languages with automatic language detection, word-level timestamps, speaker diarization, multichannel transcription, and inverse text normalization.

From

$0.002/min

One API for All Media AI.

Explore all models