Skip to main content
deepgram-core-workflow-b Implement real-time streaming transcription with Deepgram WebSocket.
Use when building live transcription, voice interfaces,
real-time captioning, or voice AI applications.
Trigger: "deepgram streaming", "real-time transcription", "live transcription",
"websocket transcription", "voice streaming", "deepgram live".
Zur Installation springen Skills Marktplatz Entdecken und erkunden Sie KI-Skills, die von der Community erstellt wurden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Prompt-Details anzeigen Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/jeremylongshore/claude-code-plugins-plus-skills --skill deepgram-core-workflow-bDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
ZIP herunterladen Herunterladen... Verwandte Berufe SOC
Basierend auf der SOC-Berufsklassifikation
Mehr aus diesem Repository Implement user sign-up and sign-in flows with Clerk.
Use when building authentication UI, customizing sign-in experience,
or implementing OAuth social login.
Trigger with phrases like "clerk sign-in", "clerk sign-up",
"clerk login flow", "clerk OAuth", "clerk social login".
Implement session management and middleware with Clerk.
Use when managing user sessions, configuring route protection,
or implementing token refresh and custom JWT templates.
Trigger with phrases like "clerk session", "clerk middleware",
"clerk route protection", "clerk token", "clerk JWT".
Configure enterprise SSO, role-based access control, and organization management.
Use when implementing SSO integration, configuring role-based permissions,
or setting up organization-level controls.
Trigger with phrases like "clerk SSO", "clerk RBAC",
"clerk enterprise", "clerk roles", "clerk permissions", "clerk organizations".
name deepgram-core-workflow-b description Implement real-time streaming transcription with Deepgram WebSocket.
Use when building live transcription, voice interfaces,
real-time captioning, or voice AI applications.
Trigger: "deepgram streaming", "real-time transcription", "live transcription",
"websocket transcription", "voice streaming", "deepgram live".
allowed-tools Read, Write, Edit, Bash(npm:*), Bash(pip:*), Grep version 1.13.0 license MIT author Jeremy Longshore <jeremy@intentsolutions.io> tags ["saas","deepgram","voice-ai","transcription","streaming","websocket"] compatibility Designed for Claude Code, also compatible with Codex and OpenClaw
Deepgram Core Workflow B: Live Streaming Transcription
Overview
Real-time streaming transcription using Deepgram's WebSocket API. The SDK manages the WebSocket connection via listen.live(). Covers microphone capture, interim/final result handling, speaker diarization, UtteranceEnd detection, auto-reconnect, and building an SSE endpoint for browser clients.
Prerequisites
@deepgram/sdk installed, DEEPGRAM_API_KEY configuredAudio source: microphone (via Sox/rec), file stream, or WebSocket audio from browser
For mic capture: sox installed (apt install sox / brew install sox)
Instructions
Step 1: Basic Live Transcription
import { createClient, LiveTranscriptionEvents } from '@deepgram/sdk' ;
const deepgram = createClient (process.env .DEEPGRAM_API_KEY !);
const connection = deepgram.listen .live ({
model : 'nova-3' ,
language : 'en' ,
smart_format : true ,
punctuate : true ,
interim_results : true ,
utterance_end_ms : 1000 ,
vad_events : true ,
encoding : 'linear16' ,
sample_rate : 16000 ,
channels
1
on
LiveTranscriptionEvents
Open
() =>
console
log
'WebSocket connected to Deepgram'
on
LiveTranscriptionEvents
Close
() =>
console
log
'WebSocket closed'
on
LiveTranscriptionEvents
Error
(err ) =>
console
error
'Deepgram error:'
on
LiveTranscriptionEvents
Transcript
(data ) =>
const
channel
alternatives
0
transcript
if
return
if
is_final
console
log
`[FINAL] ${transcript} `
else
stdout
write
`\r[interim] ${transcript} `
on
LiveTranscriptionEvents
UtteranceEnd
() =>
console
log
'\n--- utterance end ---'
Step 2: Microphone Capture with Sox import { spawn } from 'child_process' ;
function startMicrophone (connection : any const mic = spawn ('rec' , [
'-q' ,
'-r' , '16000' ,
'-e' , 'signed' ,
'-b' , '16' ,
'-c' , '1' ,
'-t' , 'raw' ,
'-' ,
]);
mic.stdout .on ('data' , (chunk : Buffer {
if (connection.getReadyState () === 1 ) {
connection.send (chunk);
}
});
mic.on ('error' , (err ) => {
console .error ('Microphone error:' , err.message );
console .log ('Install sox: apt install sox / brew install sox' );
});
return mic;
}
const mic = startMicrophone (connection);
process.on ('SIGINT' , () => {
mic.kill ();
connection.finish ();
setTimeout (() => process.exit (0 ), 2000 );
});
Step 3: Live Diarization const connection = deepgram.listen .live ({
model : 'nova-3' ,
smart_format : true ,
diarize : true ,
interim_results : false ,
utterance_end_ms : 1500 ,
encoding : 'linear16' ,
sample_rate : 16000 ,
channels : 1 ,
});
connection.on (LiveTranscriptionEvents .Transcript , (data ) => {
if (!data.is_final ) return ;
const words = data.channel .alternatives [0 ]?.words ?? [];
if (words.length === 0 ) return ;
let currentSpeaker = words[0 ].speaker ;
let segment = '' ;
for (const word of words) {
if (word.speaker !== currentSpeaker) {
console .log (`Speaker ${currentSpeaker} : ${segment.trim()} ` );
currentSpeaker = word.speaker ;
segment = '' ;
}
segment += ` ${word.punctuated_word ?? word.word} ` ;
}
console .log (`Speaker ${currentSpeaker} : ${segment.trim()} ` );
});
Step 4: Auto-Reconnect with Backoff class ReconnectingLiveTranscription {
private client : ReturnType <typeof createClient>;
private connection : any = null ;
private reconnectAttempts = 0 ;
private maxReconnectAttempts = 10 ;
private baseDelay = 1000 ;
constructor (apiKey : string , private options : Record <string , any >this .client = createClient (apiKey);
}
connect (this .connection = this .client .listen .live (this .options );
this .connection .on (LiveTranscriptionEvents .Open , () => {
console .log ('Connected' );
this .reconnectAttempts = 0 ;
});
this .connection .on (LiveTranscriptionEvents .Close , () => {
this .scheduleReconnect ();
});
this .connection .on (LiveTranscriptionEvents .Error , (err : Error {
console .error ('Connection error:' , err.message );
this .scheduleReconnect ();
});
return this .connection ;
}
private scheduleReconnect (if (this .reconnectAttempts >= this .maxReconnectAttempts ) {
console .error ('Max reconnection attempts reached' );
return ;
}
const delay = this .baseDelay * Math .pow (2 , this .reconnectAttempts )
+ Math .random () * 1000 ;
this .reconnectAttempts ++;
console .log (`Reconnecting in ${Math .round(delay)} ms (attempt ${this .reconnectAttempts} )` );
setTimeout (() => this .connect (), delay);
}
send (chunk : Buffer if (this .connection ?.getReadyState () === 1 ) {
this .connection .send (chunk);
}
}
close (this .maxReconnectAttempts = 0 ;
this .connection ?.finish ();
}
}
Step 5: SSE Endpoint for Browser Clients import express from 'express' ;
import { createClient, LiveTranscriptionEvents } from '@deepgram/sdk' ;
const app = express ();
app.get ('/api/transcribe/stream' , (req, res ) => {
res.setHeader ('Content-Type' , 'text/event-stream' );
res.setHeader ('Cache-Control' , 'no-cache' );
res.setHeader ('Connection' , 'keep-alive' );
const deepgram = createClient (process.env .DEEPGRAM_API_KEY !);
const connection = deepgram.listen .live ({
model : 'nova-3' ,
smart_format : true ,
interim_results : true ,
encoding : 'linear16' ,
sample_rate : 16000 ,
channels : 1 ,
});
connection.on (LiveTranscriptionEvents .Transcript , (data ) => {
const transcript = data.channel .alternatives [0 ]?.transcript ;
if (transcript) {
res.write (`data: ${JSON .stringify({
transcript,
is_final: data.is_final,
speech_final: data.speech_final,
})} \n\n` );
}
});
req.on ('close' , () => {
connection.finish ();
});
});
Step 6: KeepAlive for Long Sessions
connection.on (LiveTranscriptionEvents .Open , () => {
const keepAliveInterval = setInterval (() => {
if (connection.getReadyState () === 1 ) {
connection.keepAlive ();
}
}, 8000 );
connection.on (LiveTranscriptionEvents .Close , () => {
clearInterval (keepAliveInterval);
});
});
Output
Live WebSocket transcription with interim/final results
Microphone capture pipeline (Sox -> Deepgram)
Speaker diarization in streaming mode
Auto-reconnect with exponential backoff and jitter
SSE endpoint for browser integration
KeepAlive handling for long sessions
Error Handling Issue Cause Solution WebSocket closes immediately Invalid API key or bad encoding params Check key, verify encoding/sample_rate match audio No transcripts received Audio not being sent or wrong format Verify connection.send(chunk) is called with raw PCM High latency Network congestion Use interim_results: true for perceived speed rec command not foundSox not installed apt install sox or brew install soxConnection drops after 10s No audio + no KeepAlive Send connection.keepAlive() every 8s Garbled output Sample rate mismatch Ensure audio sample rate matches sample_rate option
Resources
Next Steps Proceed to deepgram-data-handling for transcript processing and storage patterns.
