Audio becomes more useful when applications can transcribe it, analyze the resulting text, or speak a response. Deepgram provides speech-to-text, text-to-speech, text intelligence, and voice-agent APIs. It appears in G2’s Voice Recognition Software category.
Create a Deepgram API key and choose the capability your workflow needs: prerecorded or streaming speech-to-text, text-to-speech, text analysis, or the Voice Agent API. Your application routes the results or generated audio to its destination. For example, a Node.js service can transcribe a recorded customer interview and create a Notion page with the text. Prerecorded transcription also supports asynchronous callbacks.
This guide compares Deepgram integration methods, examines relevant G2 reviews, and demonstrates a Deepgram-to-Notion transcript workflow using Node.js.
Methodology: We reviewed Deepgram G2 submissions dated October 1, 2025, through October 31, 2026, for explicit API and integration experiences. We checked the technical instructions against Deepgram and Notion’s official documentation in November 2026. Linked reviews are qualitative examples, not a measure of overall sentiment.
Deepgram API integration can transcribe recorded or live audio, analyze text, generate spoken audio, and run a conversational voice agent. Your application supplies the surrounding workflow, such as storing a transcript, showing captions, or connecting an agent to a phone system.
| Use case | What the integration enables | Business example |
| Interview documentation | Transcribe a recording and save the response in a workspace. | A research team adds an approved customer interview transcript to a Notion page. |
| Contact center analysis | Transcribe call recordings and use supported text analysis features to identify topics or sentiment. | A support team reviews recurring issues across authorized call transcripts. |
| Live captions | Receive streaming recognition results while audio arrives. | An events team displays captions during a live webinar. |
| Conversational voice agents | Use the Voice Agent API to combine listening, reasoning, and spoken replies in a live session. | A phone assistant answers a caller and queries an approved order-status service. |
| Spoken responses | Turn application text into audio using text-to-speech. | A service plays a dynamic appointment confirmation over a supported call audio connection. |
| Text intelligence | Analyze submitted text for supported summaries, topics, intents, or sentiment. | A research team groups approved interview transcripts by topic before review. |
These are implementation examples. The Voice Agent API, text-to-speech API, and text analysis API require different requests and output handling; the tutorial below covers prerecorded speech-to-text only.
Choose prerecorded REST transcription for completed files, streaming speech-to-text for live captions, text-to-speech for generated audio, and the Voice Agent API for a complete conversational loop. An official SDK can wrap supported operations, while a prerecorded transcription callback handles asynchronous delivery.
| Integration method | What it enables | When to use it |
| Prerecorded REST API | POST audio bytes or an accessible media URL to /v1/listen. |
Batch transcription of interviews, calls, and uploaded recordings. |
| Streaming speech-to-text | Send live audio and receive recognition results through a WebSocket. | Captions or voice features that need results during a session. |
| Text-to-speech API | Convert text to audio with a single request or supported streaming transport. | Dynamic prompts, announcements, or spoken application responses. |
| Voice Agent API | Exchange audio and control messages over a conversational WebSocket. | A live assistant that must listen and speak during the same session. |
| Text analysis API | Submit text for supported summary, topic, intent, or sentiment analysis. | Classifying or reviewing content after transcription. |
| Official SDKs | Call documented Deepgram operations from supported languages. | Applications that prefer language-specific clients over direct HTTP. |
| Transcription callback | Receive a prerecorded result at a configured callback URL. | Longer processing jobs that should complete asynchronously. |
The API overview documents Deepgram’s speech, text-to-speech, voice-agent, and account APIs. The callback guide describes callback authentication and retry behavior; treat it as a separate design from the synchronous example below.
The linked reviewers describe specific integration experiences: straightforward initial API setup and useful streaming transcription, alongside questions about advanced documentation, changing model parameters, and credential management. Their observations reflect their own deployments.
| Review theme | What G2 users report | Integration takeaway |
| Getting started | A reviewer found the integration easy and the documentation clear for the initial setup. | A small prototype may be quick to build, but verify its production configuration. |
| Streaming workflow | A phone-agent builder reports using the streaming API with live call audio. | Test the target audio format, accents, and noisy calls before rollout. |
| Advanced setup | A reviewer describes documentation gaps for unusual feature combinations. | Check exact model and parameter compatibility before deploying. |
One G2 reviewer says they got an integration working without contacting support and found the setup documentation self-explanatory. Another reviewer running a phone agent describes using Deepgram’s streaming API to process live phone audio. These are concrete examples of developer access and real-time use, not guarantees of the same results for other audio.
A reviewer working with an API pipeline asks for clearer guidance on edge cases involving feature combinations. The phone-agent reviewer above also says switching to Nova-3 required a change from the older keywords option. Deepgram’s current prerecorded API reference confirms that Nova-3 uses keyterm instead of keywords. A separate reviewer reports friction managing team API keys. These are individual reports, so teams should test their own model, governance, and audio conditions.
This workflow transcribes a short, authorized interview recording from an accessible URL and creates a child page in Notion for a team to review. It uses documented REST endpoints for both services; no private credentials appear in the article.
Note: The API operations and example code were checked against Deepgram and Notion’s official documentation as of November 2026, but were not independently tested with live credentials. The sample is a small synchronous workflow; production ingestion, retries, and duplicate prevention require additional work.
Choose an audio file that Deepgram can access by URL, or adapt the request to upload local bytes. Obtain permission to process and store the recording. In Notion, create a parent page for interview transcripts and share it with your connection so that it can insert content. Copy that page’s ID.
Deepgram’s prerecorded audio guide explains remote and local file requests. Notion’s Create a page reference describes the parent page and content requirements.
Create a Deepgram project API key in the console. Create a Notion internal connection with insert-content access to the parent page, then store both tokens only on the server. The example expects DEEPGRAM_API_KEY, NOTION_API_KEY, NOTION_PARENT_PAGE_ID, and AUDIO_URL as environment variables.
See Deepgram’s API key guide and Notion’s internal connections guide.
Use a supported Node.js runtime with built-in fetch(). The following complete script checks both HTTP responses, avoids printing secrets, and stops if Deepgram returns no transcript. It creates a Notion page under the configured parent; rerunning it creates another page.
// save as transcribe-to-notion.mjs
const required = ['DEEPGRAM_API_KEY', 'NOTION_API_KEY',
'NOTION_PARENT_PAGE_ID', 'AUDIO_URL'];
for (const name of required) {
if (!process.env[name]) throw new Error(`Missing ${name}`);
}
const audioUrl = new URL(process.env.AUDIO_URL);
if (audioUrl.protocol !== 'https:') throw new Error('Use an HTTPS audio URL');
const dg = await fetch(
'https://api.deepgram.com/v1/listen?model=nova-3&smart_format=true',
{
method: 'POST',
headers: {
Authorization: `Token ${process.env.DEEPGRAM_API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ url: audioUrl.href })
}
);
if (!dg.ok) throw new Error(`Deepgram HTTP ${dg.status}`);
const data = await dg.json();
const transcript = data.results?.channels?.[0]?.alternatives?.[0]?.transcript;
if (typeof transcript !== 'string' || !transcript.trim()) {
throw new Error('Deepgram returned no transcript');
}
// Notion rich-text items have size limits; this example is for short audio.
const chunks = transcript.match(/[\s\S]{1,1800}/g) || [];
if (chunks.length > 90) throw new Error('Transcript too long for this example');
const title = `Interview transcript ${new Date().toISOString()}`;
const notion = await fetch('https://api.notion.com/v1/pages', {
method: 'POST',
headers: {
Authorization: `Bearer ${process.env.NOTION_API_KEY}`,
'Notion-Version': '2026-03-11',
'Content-Type': 'application/json'
},
body: JSON.stringify({
parent: { type: 'page_id', page_id: process.env.NOTION_PARENT_PAGE_ID },
properties: {
title: { type: 'title', title: [{ type: 'text', text: { content: title } }] }
},
children: chunks.map(part => ({
object: 'block', type: 'paragraph',
paragraph: { rich_text: [{ type: 'text', text: { content: part } }] }
}))
})
});
if (!notion.ok) throw new Error(`Notion HTTP ${notion.status}`);
const page = await notion.json();
console.log('Created Notion page:', page.url);
The Deepgram response path results.channels[0].alternatives[0].transcript is shown in its response guide. The Notion request uses the documented page creation endpoint and a page parent. Confirm the target workspace schema and access before running it.
For longer audio, use a durable job design, additional Notion block batches, and appropriate retry handling. If you choose Deepgram’s callback mode, authenticate incoming callbacks and account for its documented retries rather than treating a callback as a one-time event.
Before deployment, validate audio access, model options, transcript quality, data handling, and the connected application’s limits against your actual workflow.
| Consideration | What to check | Why it matters |
| Audio source | Confirm Deepgram can reach the URL or use the local-file request form. | An inaccessible URL prevents transcription. |
| Model parameters | Check selected model and supported options; Nova-3 uses keyterm, not keywords. |
An incompatible option can fail or be ignored. |
| Transcript quality | Test accents, noise, domain vocabulary, and review needs. | Recognition results can affect downstream records. |
| Data handling | Review permission, storage, redaction, and Deepgram model-improvement settings. | Recordings and transcript pages can contain sensitive content. |
| Notion capacity | Check page access, block size, request limits, and long-transcript handling. | The short sample deliberately stops before oversized writes. |
| Usage cost | Review the current model and optional-feature rates. | Billing depends on selected speech services and usage. |
Check out other API integration guides:
Got more questions? Find answers below.
Yes. Deepgram documents streaming speech-to-text for applications receiving audio as it arrives. Use its API overview to select the correct streaming endpoint and test your audio format and latency requirements.
Yes. Its prerecorded guide shows a binary upload request and a JavaScript SDK transcribeFile example. The tutorial above uses a URL to keep the sample focused.
Deepgram’s prerecorded guide says it does not store transcripts for later retrieval. Save the API response or configure a callback destination you control. The example writes the returned text to Notion.
Nova-3 supports keyterm prompting. Deepgram’s API reference says the older keywords option is not supported with Nova-3. Confirm the exact parameter on the endpoint and model you use.
Yes. Deepgram’s callback guide describes supplying a callback URL and receiving a request ID while processing continues. Authenticate callbacks and plan for possible retries. This is separate from the synchronous Node.js example.
Deepgram currently offers a starting credit and usage-based plans; using the API beyond any included credit can incur charges. Model choice and optional features affect cost. Check Deepgram’s live pricing before deployment.
Yes. Deepgram’s text-to-speech API converts a single text request into audio, and its streaming API handles continuous text. Choose the transport and model that fit the destination’s audio format and latency needs; these APIs are separate from the transcription tutorial.
Yes. Deepgram’s Voice Agent API supports a conversational WebSocket flow with listening, reasoning, and spoken responses. Its Plivo phone-agent guide shows how an application can bridge call audio to that API. An IVR or phone deployment still needs a compatible telephony connection, audio transport, and workflow configuration.
Install deepgram-sdk, create a DeepgramClient with your server-side API key, open the local file in binary mode, and call client.listen.v1.media.transcribe_file(request=audio_file.read(), model="nova-3"). Read the transcript from response.results.channels[0].alternatives[0].transcript. This is the current Python SDK v5 form; older SDK examples use different method paths. See Deepgram’s official Python SDK migration guide and prerecorded audio guide.
Open Deepgram’s streaming speech-to-text WebSocket with an API key, send audio frames in a supported format as they arrive, and handle interim and final transcript messages separately. The streaming API reference documents the connection and parameters; Deepgram’s live phone-transcription guide shows a server forwarding audio into the WebSocket. This streaming path is separate from the prerecorded REST example above.
Have Twilio send call audio to your server with a one-way <Start><Stream> Media Stream. Forward those audio frames to Deepgram’s streaming speech-to-text WebSocket and process its interim or final transcripts. Deepgram’s Twilio STT guide documents the bridge and distinguishes transcription from a two-way Voice Agent flow, which uses different Twilio streaming behavior. Verify consent and audio format for the call you process.
It can be when a product needs documented speech-to-text, text-to-speech, or a conversational Voice Agent API. Choose the combination that fits your audio transport and latency requirements, then prototype with your own languages, noise conditions, and cost profile. Deepgram’s API overview documents the available paths; the G2 experiences above are individual reports, not a performance guarantee.
Yes. Deepgram documents prerecorded speech-to-text, live speech-to-text, and text-to-speech APIs. Use speech-to-text to turn audio into text, and text-to-speech to generate audio from text; they have different request and output formats.
Start with one recording type and a clear destination for the transcript. Verify transcription quality and access controls before expanding to live audio or automated decisions.
Comparing speech tools? Read G2’s voice recognition software guide for broader options and user perspectives.