canonical: https://jentic.com/apis/deepgram.com/deepgram

# Deepgram API

Transcribe audio to text, synthesize speech from text, and understand language through 39 endpoints covering Deepgram's AI speech platform. POST /v1/listen transcribes pre-recorded audio and video, with query parameters for speaker diarization, punctuation, paragraphs, utterances, topic detection, sentiment, intents, and redaction, plus a BCP-47 language hint that defaults to en. The Speak endpoint converts text to natural-sounding speech using Aura voice models. The API also provides project management, API key administration, usage tracking, and listings of the public and custom-trained transcription models.

## For AI agents

Transcribe audio to text, synthesize speech from text, and analyze language content. Takes a BCP-47 language hint and supports speaker diarization, topic detection, and keyword or key-term prompting for domain-specific terminology.

## Scope

Does not handle audio editing, music generation, or real-time voice calling - use for speech-to-text transcription, text-to-speech synthesis, and text understanding only.

## Capabilities

- Transcribe pre-recorded audio files with speaker diarization, punctuation, and paragraph segmentation
- Convert text to natural-sounding speech with 63 Aura voice models and configurable encoding, container, sample rate, and bit rate
- Analyze text for intent, sentiment, topic detection, and summarization via the Read endpoint
- Select from the 29 public transcription models the spec enumerates, including nova-3, nova-2-meeting, nova-phonecall and voicemail, or a custom model trained by Deepgram (default base-general)
- Track transcription usage, billing breakdown, and project-level consumption across API keys
- List the think models available for AI agent processing via GET /v1/agent/settings/think/models

## Use cases

### AI Agent Audio Transcription Pipeline

AI agents transcribe audio content (meetings, calls, podcasts, voicemails) into structured text through Jentic. The agent posts a JSON body carrying an audio URL, or the raw file as application/octet-stream, to the Listen endpoint with parameters for diarization, punctuation, and paragraphs, and receives each word with start and end times plus a speaker number. Jentic handles API key injection, so the agent focuses on processing the transcript output for downstream tasks like summarization or search indexing.

Example prompt: POST an audio file URL to /v1/listen with parameters diarize=true, punctuate=true, and model=nova-3, then extract the transcript text with speaker labels from the response

### Text-to-Speech Generation

Generate natural-sounding speech audio from text input for voice assistants, accessibility features, or content narration. POST /v1/speak takes a JSON body whose only required field is text and returns the audio as application/octet-stream. The encoding parameter selects linear16, flac, mulaw, alaw, mp3 (the default), opus, or aac, with container wav by default and ogg for opus, and sample_rate and bit_rate are configurable per encoding. The model parameter offers 63 Aura voices, and a callback URL can be supplied for asynchronous delivery.

Example prompt: POST a JSON body with a text field to /v1/speak using model=aura-asteria-en and receive the generated audio in the default mp3 encoding

### Meeting and Call Analytics

Extract actionable intelligence from meeting recordings and phone calls with speaker-attributed transcription, topic detection, and summarization. The model parameter offers meeting-tuned and telephony-tuned options such as nova-2-meeting, enhanced-meeting, nova-phonecall and enhanced-phonecall, filler_words transcribes interruptions like 'uh' and 'um' rather than dropping them, and keywords or keyterm prompting boosts specialized terminology and brands. Each word in the response carries start and end times plus a speaker number, which lets an agent navigate to a precise moment in the recording.

Example prompt: Transcribe a meeting recording via POST /v1/listen with model=meeting, diarize=true, summarize=true, and topics=true, then parse the response for speaker turns and topic segments

### Document and Text Understanding

Analyze written text for intent, sentiment, topics, and summaries through the Read endpoint. This enables processing of transcripts, emails, support tickets, and documents without audio input. The API returns structured analysis including detected topics with confidence scores, overall sentiment, and concise summaries suitable for search indexing or automated routing.

Example prompt: POST a text document to /v1/read with intents=true and summarize=true, then extract the detected intents and summary from the response

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /v1/listen | Transcribe audio to text with model and language options |
| POST | /v1/speak | Synthesize text to speech audio |
| POST | /v1/read | Analyze text for intent, sentiment, and topics |
| GET | /v1/models | List available transcription models |
| GET | /v1/projects | List all projects for the account |
| GET | /v1/projects/{project_id}/usage | Get usage statistics for a project |
| POST | /v1/projects/{project_id}/keys | Create a new API key for a project |
| POST | /v1/auth/grant | Generate a temporary JWT for scoped access |

## Key resources

- **Listen** — Speech-to-text transcription for pre-recorded audio with diarization, punctuation, and model selection
- **Speak** — Text-to-speech synthesis with 63 Aura voice models and configurable encoding, container, sample rate, and bit rate
- **Read** — Text analysis for intent detection, sentiment, topics, and summarization
- **Projects** — Project management including members, keys, usage tracking, and billing
- **Models** — Metadata on the latest public models, with include_outdated for non-latest versions and per-project endpoints for custom models
- **Agent** — Read-only listing of the think models available for AI agent processing

## Why Jentic

- **Setup:** Wiring the Deepgram API by hand means learning its two auth styles, the Authorization: Token API key and the Bearer JWT, choosing the right production or agent host, and mapping listen, speak, and read across many endpoints. Through Jentic you install once, import the Deepgram API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Deepgram puts the project id in the URL path (/v1/projects/{project_id}/usage, /v1/projects/{project_id}/keys), so a rule can pin your agent to one project. You choose the operations it may call, so state-changing ones like creating project keys or granting auth are included only if you add them.
- **Credential handling:** Your Deepgram API key is stored once, encrypted, by your own Jentic One instance and applied as the Authorization: Token header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'transcribe an audio recording' or 'synthesize speech from text', and Jentic returns the matching Deepgram Listen, Speak, or Read operation with its parameter schema so the agent selects the right model and options without navigating documentation.

## Related APIs

- **AssemblyAI API** — Speech-to-text API with additional LLM-powered features like auto chapters, entity detection, and content moderation
- **Rev.ai API** — Speech-to-text service with human-in-the-loop options for higher accuracy on difficult audio
- **OpenAI API** — LLM platform for summarizing, analyzing, and extracting structured data from Deepgram transcripts
- **Spotify Web API** — Music and podcast library for sourcing audio content that Deepgram can transcribe

## FAQ

### What authentication does the Deepgram API use?

The spec declares two schemes. ApiKeyAuth sends the key in the Authorization header with a 'Token' prefix (Authorization: Token <API_KEY>), and JwtAuth sends a bearer JWT (Authorization: Bearer <JWT>). 35 of the 39 operations declare ApiKeyAuth alone; the three core voice operations, POST /v1/listen, POST /v1/speak and POST /v1/read, accept either scheme; and GET /v1/agent/settings/think/models declares no security requirement in the spec. You mint a JWT with POST /v1/auth/grant, which issues a token with a 30-second default TTL and usage::write permission for the core voice APIs. Project keys created with POST /v1/projects/{project_id}/keys require a scopes array and take either an expiration_date or a time_to_live_in_seconds. Through Jentic, the key is stored encrypted by your own Jentic One instance and applied at execution time, so agents never see the raw key.

### Can I transcribe audio with speaker identification?

Yes. Add diarize=true to your POST /v1/listen request. The spec describes the parameter as recognizing speaker changes, with each word in the transcript assigned a speaker number starting at 0. Each word object in the response carries word, punctuated_word, start, end, confidence, speaker and speaker_confidence, and adding utterances=true additionally segments the speech into semantic units that each carry their own speaker number.

### What are the rate limits for the Deepgram API?

The OpenAPI specification does not state any rate limit: it declares no limit fields, no rate-limit response headers, and no extensions carrying numeric limits. Check developers.deepgram.com for the limits that apply to your plan before sizing a workload.

### How do I transcribe an audio file through Jentic with an AI agent?

Install self-hosted Jentic One, import the Deepgram API from the Jentic API Directory, and store your Deepgram API key once. Your agent then searches by intent, for example 'transcribe audio to text', and Jentic returns the POST /v1/listen operation schema with its supported parameters (model, language, diarize, punctuate, paragraphs, summarize). The agent sends either a JSON body with the audio URL or the raw file as application/octet-stream, and your instance applies the Authorization: Token header at execution time, so the API key never appears in the agent's context.

### Which transcription models does Deepgram offer?

The spec's model parameter on POST /v1/listen enumerates 29 public models across the nova-3, nova-2, nova, enhanced and base families, including domain variants meeting, phonecall, voicemail, finance, video, conversationalai, medical, drivethru and automotive. The default is base-general and the example value is nova-3, and the parameter also accepts a custom string if Deepgram has trained a model for you. GET /v1/models returns metadata on the latest public models, with include_outdated=true for non-latest versions, and GET /v1/projects/{project_id}/models lists a project's models, which is where custom models appear.

### Does Deepgram support text-to-speech generation?

Yes. POST /v1/speak takes a JSON body whose only required field is text and returns audio as application/octet-stream. The encoding parameter accepts linear16, flac, mulaw, alaw, mp3 (the default), opus and aac; container defaults to wav and is ogg for opus, or none for no container. The model parameter selects one of 63 Aura voices, defaulting to aura-asteria-en, and sample_rate (default 24000) and bit_rate (default 48000) are constrained by the chosen encoding. For long jobs you can pass a callback URL and callback_method of POST or PUT instead of waiting on the response.

### Is there a Deepgram MCP server?

You don't need an MCP server to give your agent the Deepgram API. Jentic connects it directly from the Jentic API Directory: import the API, store your Deepgram API key once, and your agent calls the operations you allow, with no extra server's tool definitions loaded into its context.

### Can I limit what my agent is allowed to do with the Deepgram API?

Yes. Because Jentic One is self-hosted, you decide which Deepgram operations your agent may call, so you can grant transcription and synthesis only, through POST /v1/listen, POST /v1/speak, and POST /v1/read while withholding state-changing operations like POST /v1/projects/{project_id}/keys or POST /v1/auth/grant. Deepgram puts the project id in the URL path, as in /v1/projects/{project_id}/usage, so your rules can pin the agent to a single project. Your Deepgram API key is stored encrypted by your own instance and applied at execution time, so it never enters the agent's prompt or context.