Deepgram vs OpenAI Whisper API vs AssemblyAI: STT 2026

Voice app (real-time captions, dictation)    → Deepgram (streaming)
Meeting transcription (Zoom, Meets)          → Deepgram or AssemblyAI (diarization)
Podcast transcription (batch)               → Whisper API or AssemblyAI
Audio content analysis / insights           → AssemblyAI (LeMUR, sentiment, topics)
Multi-language content (100 languages)      → Whisper API
Call center analytics                       → AssemblyAI (PII, sentiment, topics)
Cheapest batch transcription               → Whisper API ($0.006/min)

npm install @deepgram/sdk

import { createClient } from "@deepgram/sdk";

const deepgram = createClient(process.env.DEEPGRAM_API_KEY!);

// Transcribe a URL
const { result, error } = await deepgram.listen.prerecorded.transcribeUrl(
  { url: "https://example.com/audio.mp3" },
  {
    model: "nova-2",
    smart_format: true,        // Punctuation, capitalization, number formatting
    diarize: true,             // Speaker identification
    language: "en",
    punctuate: true,
    utterances: true,          // Segment by speaker
  }
);

if (error) throw error;

const transcript = result.results.channels[0].alternatives[0].transcript;
console.log("Transcript:", transcript);

// Speaker-segmented output (with diarize: true, utterances: true)
for (const utterance of result.results.utterances ?? []) {
  console.log(`Speaker ${utterance.speaker}: ${utterance.transcript}`);
}

import fs from "fs";

const audioBuffer = fs.readFileSync("./audio.mp3");

const { result, error } = await deepgram.listen.prerecorded.transcribeFile(
  audioBuffer,
  {
    model: "nova-2",
    smart_format: true,
    diarize: true,
    mimetype: "audio/mp3",
  }
);

const words = result.results.channels[0].alternatives[0].words;
// words: Array of { word, start, end, confidence, speaker }

import { createClient, LiveTranscriptionEvents } from "@deepgram/sdk";

const deepgram = createClient(process.env.DEEPGRAM_API_KEY!);

async function startLiveTranscription() {
  const live = deepgram.listen.live({
    model: "nova-2",
    language: "en",
    smart_format: true,
    interim_results: true,     // Get partial results as user speaks
    endpointing: 300,          // Silence threshold to finalize a segment (ms)
  });

  live.on(LiveTranscriptionEvents.Open, () => {
    console.log("WebSocket connected");
  });

  live.on(LiveTranscriptionEvents.Transcript, (data) => {
    const transcript = data.channel.alternatives[0].transcript;
    const isFinal = data.is_final;

    if (isFinal && transcript) {
      console.log("Final:", transcript);
      // Send to UI / process
    } else if (transcript) {
      console.log("Interim:", transcript);
      // Update UI preview
    }
  });

  live.on(LiveTranscriptionEvents.Error, console.error);
  live.on(LiveTranscriptionEvents.Close, () => console.log("Disconnected"));

  return live;
}

// Send audio chunks to the live session
const liveSession = await startLiveTranscription();

// From microphone (browser)
const mediaRecorder = new MediaRecorder(stream);
mediaRecorder.addEventListener("dataavailable", (event) => {
  if (event.data.size > 0) {
    liveSession.send(event.data);
  }
});

// Close when done
liveSession.finish();

// app/api/transcribe/stream/route.ts
import { createClient, LiveTranscriptionEvents } from "@deepgram/sdk";
import { NextRequest } from "next/server";

export async function GET(req: NextRequest) {
  const deepgram = createClient(process.env.DEEPGRAM_API_KEY!);

  // Return Server-Sent Events for transcript updates
  const encoder = new TextEncoder();
  const stream = new ReadableStream({
    start(controller) {
      const live = deepgram.listen.live({ model: "nova-2", smart_format: true });

      live.on(LiveTranscriptionEvents.Transcript, (data) => {
        const transcript = data.channel.alternatives[0].transcript;
        if (transcript) {
          controller.enqueue(
            encoder.encode(`data: ${JSON.stringify({ transcript })}\n\n`)
          );
        }
      });
    },
  });

  return new Response(stream, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
    },
  });
}

npm install openai

import OpenAI from "openai";
import fs from "fs";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });

// Transcribe a local audio file
async function transcribeFile(filePath: string): Promise<string> {
  const transcript = await openai.audio.transcriptions.create({
    file: fs.createReadStream(filePath),
    model: "whisper-1",
    language: "en",              // Optional — auto-detects if omitted
    response_format: "json",     // "json" | "text" | "srt" | "vtt" | "verbose_json"
    temperature: 0,              // 0 = most confident, 1 = most creative
  });

  return transcript.text;
}

// Get subtitle format directly
async function transcribeToSRT(filePath: string): Promise<string> {
  const srt = await openai.audio.transcriptions.create({
    file: fs.createReadStream(filePath),
    model: "whisper-1",
    response_format: "srt",
  });
  return srt as unknown as string;
}

const transcript = await openai.audio.transcriptions.create({
  file: fs.createReadStream("audio.mp3"),
  model: "whisper-1",
  response_format: "verbose_json",
  timestamp_granularities: ["word"],  // Word-level timestamps
});

// Access word-level timing
for (const word of transcript.words ?? []) {
  console.log(`"${word.word}" — ${word.start}s to ${word.end}s`);
}

// Whisper can translate to English from any of 100 languages
const translation = await openai.audio.translations.create({
  file: fs.createReadStream("french-audio.mp3"),
  model: "whisper-1",
  // No language parameter needed — Whisper auto-detects and translates to English
});

console.log("English translation:", translation.text);

npm install assemblyai

import { AssemblyAI } from "assemblyai";

const client = new AssemblyAI({ apiKey: process.env.ASSEMBLYAI_API_KEY! });

// Transcribe from URL
const transcript = await client.transcripts.transcribe({
  audio_url: "https://example.com/podcast.mp3",
  speaker_labels: true,          // Speaker diarization
  auto_highlights: true,         // Key phrases and topics
  sentiment_analysis: true,      // Sentiment per sentence
  entity_detection: true,        // Named entities (persons, places, etc.)
  iab_categories: true,          // IAB content categorization
});

console.log("Transcript:", transcript.text);

// Speaker-segmented output
for (const utterance of transcript.utterances ?? []) {
  console.log(`${utterance.speaker}: ${utterance.text}`);
}

// Sentiment analysis
for (const sentence of transcript.sentiment_analysis_results ?? []) {
  console.log(`[${sentence.sentiment}] ${sentence.text}`);
}

const transcript = await client.transcripts.transcribe({
  audio_url: "https://example.com/call-recording.mp3",
  redact_pii: true,
  redact_pii_audio: true,        // Also redact PII from audio file itself
  redact_pii_policies: [
    "ssn",                       // Social security numbers
    "credit_card_number",
    "phone_number",
    "email_address",
    "person_name",
    "date_of_birth",
  ],
  // Redacted transcript: "My SSN is #### and my card is ####..."
});

// Ask questions about the audio content using LLMs
const response = await client.lemur.task({
  transcript_ids: [transcript.id],
  prompt: "Provide a concise 3-bullet summary of the key points discussed.",
  final_model: "anthropic/claude-3-5-sonnet",  // Or openai/gpt-4o
});

console.log("Summary:", response.response);

// Q&A from audio
const qaResponse = await client.lemur.questionAnswer({
  transcript_ids: [transcript.id],
  questions: [
    {
      question: "What was the main decision made in this meeting?",
      answer_format: "Single sentence",
    },
    {
      question: "What action items were mentioned?",
      answer_format: "Bulleted list",
    },
  ],
});

for (const qa of qaResponse.response) {
  console.log(`Q: ${qa.question}\nA: ${qa.answer}\n`);
}