Live transcription | Deepgram | Page 1

tight roseBOT May 20, 2025, 1:37 PM

#

Hi @fallow dock. I'm kapa.ai, your friendly support bot. I will try to answer your question by searching through the knowledge base. :wave:

#

Certainly! Based on your message, it sounds like you’re having trouble getting live transcription working in your web app. From the knowledge sources, here are some common issues and solutions when implementing Deepgram’s live transcription:

1. Audio Source

If your code is transcribing audio from a remote stream (like BBC radio), you’ll see text that doesn’t match your own speech. For example, this code:

const url = "<http://stream.live.vc.bbcmedia.co.uk/bbc_world_service";>

will transcribe the BBC World Service, not your microphone. To transcribe your own speech, you need to capture audio from the user’s microphone and send that data to Deepgram instead of a remote URL. This was a common confusion, as seen in this discussion:

“this code sample transcribes from BBC radio... You’ll want to remove that reference, and instead send audio data from another source, such as the local microphone.”
Live Transcription - Vue Example

2. Sending Audio Data

You must send raw audio data (not base64-encoded) in the correct format (e.g., linear16 or mulaw with the correct sample rate) to Deepgram’s WebSocket. If you’re using Twilio or another service, decode the base64 payload before sending:

const audio = Buffer.from(media["payload"], "base64");
connection.send(audio);

No response received from deepgram streaming websockets

3. SDK Usage

If you’re using the Deepgram JS SDK, the basic flow is:

Capture audio from the microphone (e.g., using Web Audio API or getUserMedia).
Send the audio stream to Deepgram’s live transcription endpoint.
Listen for transcription events and display the results.

#

For a working example, see the Live Audio Starter Apps or the Deepgram JS SDK documentation.

4. Example: Microphone to Deepgram (Node/Browser)

Here’s a high-level outline (you’ll need to implement microphone capture in the browser):

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

// Initialize Deepgram client
const deepgram = createClient("YOUR_DEEPGRAM_API_KEY");

// Create a live transcription connection
const connection = deepgram.listen.live({
  model: "nova-3",
  language: "en-US",
  smart_format: true,
});

// Listen for transcription events
connection.on(LiveTranscriptionEvents.Transcript, (data) => {
  console.log(data.channel.alternatives[0].transcript);
});

// Capture audio from the microphone and send to Deepgram
// (You need to implement this part using getUserMedia and process the audio buffer)

For a full browser example, see js-live-example or the official docs.

If you share your code, I can provide more targeted help.
If you’re still having trouble, please check:

Are you sending audio from the correct source (microphone, not a remote stream)?
Is the audio format and sample rate correct?
Are you handling events and errors from the Deepgram connection?

Let me know if you need a specific code example for capturing microphone audio in the browser!

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

#

@fallow dock Kapa.ai is still learning and improving, please let me know how I did by reacting below.

fallow dock May 20, 2025, 1:39 PM

#

import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import http from 'http';
import { WebSocketServer } from 'ws';
import { createClient } from '@deepgram/sdk';

dotenv.config();

const app = express();
const PORT = process.env.PORT || 3000;

app.use(cors());
app.use(express.static('public'));
app.use(express.json());

const deepgram = createClient({ apiKey: process.env.DEEPGRAM_API_KEY });

app.get('/', (_req, res) => {
res.send('✅ Deepgram minimal backend draait');
});

const server = http.createServer(app);
const wss = new WebSocketServer({ server, path: '/live' });

wss.on('connection', async (ws) => {
console.log('🟢 WebSocket client verbonden');

try {
const stream = await deepgram.listen.live({
encoding: 'webm-opus',
sample_rate: 48000,
language: 'nl'
});

stream.on('open', () => {
  console.log('🔵 Deepgram stream gestart');
});

stream.on('transcriptReceived', (data) => {
  const transcript = data.channel.alternatives[0]?.transcript;
  if (transcript && transcript.trim()) {
    ws.send(JSON.stringify({ transcript }));
    console.log('📝 Transcript ontvangen:', transcript);
  }
});

stream.on('error', (err) => {
  console.error('❌ Deepgram fout:', err);
  ws.send(JSON.stringify({ error: err.message }));
});

stream.on('close', () => {
  console.log('🔴 Deepgram stream gesloten');
});

ws.on('message', (chunk) => {
  if (chunk instanceof Buffer || chunk instanceof Uint8Array) {
    stream.send(chunk);
  }
});

ws.on('close', () => {
  stream.finish();
  console.log('⚪ WebSocket client gesloten');
});

} catch (err) {
console.error('❌ Deepgram connectie mislukt:', err);
ws.send(JSON.stringify({ error: 'Deepgram WebSocket mislukt' }));
ws.close();
}
});

server.listen(PORT, () => {
console.log(🚀 Server draait op http://localhost:${PORT});
});

#

see my code above

#

@tight rose

tight roseBOT May 20, 2025, 1:42 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

Sorry @fallow dock, I seem to be having a bit of trouble. Don't worry though, I've pinged my support and they will try to fix me up! :technologist:

Perhaps try again in 15mins?

fallow dock May 20, 2025, 1:45 PM

#

@tight rose

tight roseBOT May 20, 2025, 1:45 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

Sorry @fallow dock, I seem to be having a bit of trouble. Don't worry though, I've pinged my support and they will try to fix me up! :technologist:

Perhaps try again in 15mins?

fallow dock May 20, 2025, 1:47 PM

#

This is my code @tight rose : import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import http from 'http';
import { WebSocketServer } from 'ws';
import { createClient } from '@deepgram/sdk';

dotenv.config();

const app = express();
const PORT = process.env.PORT || 3000;

app.use(cors());
app.use(express.static('public'));
app.use(express.json());

const deepgram = createClient({ apiKey: process.env.DEEPGRAM_API_KEY });

app.get('/', (_req, res) => {
res.send('✅ Deepgram minimal backend draait');
});

const server = http.createServer(app);
const wss = new WebSocketServer({ server, path: '/live' });

wss.on('connection', async (ws) => {
console.log('🟢 WebSocket client verbonden');

try {
const stream = await deepgram.listen.live({
encoding: 'webm-opus',
sample_rate: 48000,
language: 'nl'
});

stream.on('open', () => {
  console.log('🔵 Deepgram stream gestart');
});

stream.on('transcriptReceived', (data) => {
  const transcript = data.channel.alternatives[0]?.transcript;
  if (transcript && transcript.trim()) {
    ws.send(JSON.stringify({ transcript }));
    console.log('Transcript ontvangen:', transcript);
  }
});

stream.on('error', (err) => {
  console.error('Deepgram fout:', err);
  ws.send(JSON.stringify({ error: err.message }));
});

stream.on('close', () => {
  console.log('Deepgram stream gesloten');
});

ws.on('message', (chunk) => {
  if (chunk instanceof Buffer || chunk instanceof Uint8Array) {
    stream.send(chunk);
  }
});

ws.on('close', () => {
  stream.finish();
  console.log('WebSocket client gesloten');
});

} catch (err) {
console.error('Deepgram connectie mislukt:', err);
ws.send(JSON.stringify({ error: 'Deepgram WebSocket mislukt' }));
ws.close();
}
});

server.listen(PORT, () => {
console.log(🚀 Server draait op http://localhost:${PORT});
});

tight roseBOT May 20, 2025, 1:47 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

Your backend code for live transcription with Deepgram looks structurally correct and follows the typical pattern for integrating Deepgram’s live streaming API with a WebSocket server. Here are some key points and suggestions based on the knowledge sources and common troubleshooting steps:

1. Deepgram SDK Usage

You are correctly initializing the Deepgram client and creating a live transcription stream with the appropriate options (encoding: 'webm-opus', sample_rate: 48000, language: 'nl').
You are listening for the transcriptReceived event and sending the transcript back to the WebSocket client, which is the expected approach for real-time transcription using the Deepgram SDK [Node SDK Streaming Transcription].

2. Event Handling

You are handling the open, transcriptReceived, error, and close events on the Deepgram stream, which is recommended.
You are also handling the message and close events on the WebSocket connection, which is correct.

3. Common Issues to Check

Based on the knowledge sources, if you are not receiving transcriptions or the connection closes unexpectedly, consider the following:

Audio Data Format:
Ensure that the audio data sent from the client is actually in webm-opus format and at a 48kHz sample rate. If the encoding or sample rate does not match what Deepgram expects, the connection may close or you may not receive transcriptions [Troubleshooting WebSockets].

#

No Audio Data:
If no audio data is sent within about 10 seconds, Deepgram will close the connection. Make sure your client is streaming audio data as soon as the connection is established [Troubleshooting WebSockets].
KeepAlive:
If there are intentional silences, you may need to send KeepAlive messages to prevent the connection from closing. However, for most real-time use cases, continuous audio should suffice [Node SDK Streaming Transcription].
Error Handling:
If you receive errors, log the full error object for more details. Sometimes, the error message will indicate issues like unsupported encoding or invalid API key.

4. Reference Example

Your code closely matches the recommended structure in the official Deepgram Node.js SDK documentation and community examples [Node SDK Streaming Transcription].

5. Next Steps

Check the client-side code:
Make sure your client is capturing audio in the correct format and sending it as binary data over the WebSocket.
Log all events and errors:
Add more detailed logging for all events, especially errors, to help diagnose issues.
Test with a known-good audio source:
If possible, test with a static audio file in the correct format to rule out client-side capture issues.

If you are still not receiving transcriptions or the connection closes, please provide details about the client-side implementation and any error messages you see. This will help further diagnose the issue.

#

Let me know if you need a sample client implementation or have specific error logs to review!

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

#

@fallow dock Kapa.ai is still learning and improving, please let me know how I did by reacting below.

fallow dock May 20, 2025, 1:51 PM

#

@tight rose error logs: 🎤 Opname gestart
test.html:24 🟢 WebSocket open
test.html:33 ⚠️ Deepgram fout: Unexpected server response: 400
ws.onmessage @ test.html:33
test.html:74 ⏹️ Opname gestopt
test.html:25 ⚪ Gesloten

tight roseBOT May 20, 2025, 1:51 PM

#

Let me check the knowledge base for you again. One moment! :books:

covert parcelBOT May 20, 2025, 1:51 PM

#

Hey there, it looks like you've been talking with Kapa for a bit. If you need additional help, you should consider moving to #1115960287183511643 where our team can answer your query.

tight roseBOT May 20, 2025, 1:52 PM

#

Your error log shows that Deepgram is returning a 400 error (Unexpected server response: 400) when you try to establish the live transcription stream. This means the Deepgram server is rejecting your WebSocket connection due to a bad request.

Based on the knowledge sources, here are the most common causes and troubleshooting steps for this error:

1. Audio Encoding and Sample Rate Mismatch

A frequent cause of a 400 error is a mismatch between the audio encoding and sample rate you specify in your Deepgram stream options and the actual audio data you send. For example, if you specify encoding: 'webm-opus' and sample_rate: 48000, but your client is sending a different format or sample rate, Deepgram will reject the connection [WebSocket Troubleshooting].

Action:
Double-check that your client is capturing and sending audio in webm-opus format at 48kHz. If you are using the browser’s MediaRecorder, ensure it is set to record in this format.

2. Invalid or Unsupported Query Parameters

If you provide an unsupported or misspelled option in your Deepgram stream configuration, the server will return a 400 error [WebSocket Troubleshooting].

Action:
Review your Deepgram stream options for typos or unsupported parameters.

3. API Key or Permissions

A 400 error can also occur if your API key is missing, invalid, or does not have access to the requested model or language [Errors].

Action:
Ensure your API key is valid and has access to the nld (Dutch) language and the model you are requesting.

#

4. Language Detection in Streaming

If you are trying to use language detection (detect_language: true) with live streaming, this is not supported and will result in a 400 error [Language detection error].

5. General Debugging Steps

Log the full error object from the Deepgram stream for more details.
Try connecting with minimal options (just encoding, sample_rate, and language) to isolate the issue.
Test with a known-good audio source and format.

Summary:
The most likely cause is a mismatch between the audio format you specify and what your client is actually sending. Double-check your client-side audio capture settings and ensure they match the Deepgram stream options exactly. If the problem persists, log the full error object for more details, as it may contain a more specific message from Deepgram about what is wrong with the request.

If you can share your client-side audio capture code, I can help review it for potential issues.

References:

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

#

@fallow dock Kapa.ai is still learning and improving, please let me know how I did by reacting below.

fallow dock May 20, 2025, 1:56 PM

#

@tight rose does this only work in Google Chrome and not in Opera GX?

tight roseBOT May 20, 2025, 1:56 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

The knowledge sources do not explicitly mention browser compatibility for Deepgram’s live transcription, specifically regarding Opera GX. However, there is a related discussion about browser compatibility issues, particularly with Safari, where it was noted that some Deepgram JavaScript examples only work in Chrome and not in Safari due to audio format support (e.g., Safari not supporting audio/webm) [js-live-example doesn't work in Safari].

Opera GX is based on Chromium, like Google Chrome, so in most cases, features that work in Chrome should also work in Opera GX, provided the browser supports the required audio formats (such as webm-opus). If you encounter issues in Opera GX, it is likely due to differences in how the browser handles audio capture or WebSocket connections, not a limitation of Deepgram itself.

If you experience problems, verify that Opera GX supports the audio format you are using and that your client-side code is compatible with Chromium-based browsers. If issues persist, testing in Chrome can help determine if the problem is browser-specific.

In summary, there is no official statement in the knowledge sources that Deepgram live transcription only works in Chrome and not in Opera GX, but compatibility should generally be similar due to their shared Chromium base. If you encounter issues, they are likely related to browser-specific audio support rather than Deepgram itself.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

#

@fallow dock Kapa.ai is still learning and improving, please let me know how I did by reacting below.

fallow dock May 20, 2025, 2:17 PM

#

<@&1251656420219162768> still getting errors in my backend: [Symbol(kTarget)]: WebSocket {

_events: [Object: null prototype] {
  open: [Function],
  close: [Function],
  error: [Function],
_maxListeners: undefined,
_binaryType: 'nodebuffer',
_closeFrameReceived: false,
_closeFrameSent: false,

_closeTimer: null,
_paused: false,
_socket: null,
_bufferedAmount: 0,
_redirects: 0,
_autoPong: true,
_url: 'wss://api.deepgram.com/v1/listen?encoding=webm-opus&sample_rate=48000&language=nl',
  _maxListeners: undefined,
  outputData: [],
  [Symbol(kCapture)]: false,
  [Symbol(kBytesWritten)]: 0,
  writable: true,
  [Symbol(kNeedDrain)]: false,
  destroyed: true,
  [Symbol(corked)]: 0,
  _last: true,
  chunkedEncoding: false,
  [Symbol(errored)]: null,
  _defaultKeepAlive: true,
  [Symbol(kRejectNonStandardBodyWrites)]: false,
  useChunkedEncodingByDefault: false,
  [Symbol(kUniqueHeaders)]: null,
  sendDate: false,
  [Symbol(kAborted)]: true,
  _removedContLen: false,
},
[Symbol(shapeMode)]: false,
[Symbol(kCapture)]: false

[Symbol(kError)]: Error: Unexpected server response: 400
finished: true,
_headerSent: true,
_closed: false,
at HTTPParser.parserOnIncomingClient (node:_http_client:702:27)
at HTTPParser.parserOnHeadersComplete (node:_http_common:118:17)
at TLSSocket.socketOnData (node:_http_client:544:22)
'Content-Type: application/json\r\n' +
'X-Client-Info: Deepgram/sdk; server; v3.13.0\r\n' +
at readableAddChunkPushByteMode (node:internal/streams/readable:512:3)
at Readable.push (node:internal/streams/readable:392:5)
'Sec-WebSocket-Version: 13\r\n' +
[Symbol(kMessage)]: 'Unexpected server response: 400'

    'Upgrade: websocket\r\n' +

}

    'Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits\r\n' +

Deepgram stream gesloten

#

@tight rose still getting errors in my backend: [Symbol(kTarget)]: WebSocket {

_events: [Object: null prototype] {
  open: [Function],
  close: [Function],
  error: [Function],
_maxListeners: undefined,
_binaryType: 'nodebuffer',
_closeFrameReceived: false,
_closeFrameSent: false,

_closeTimer: null,
_paused: false,
_socket: null,
_bufferedAmount: 0,
_redirects: 0,
_autoPong: true,
_url: 'wss://api.deepgram.com/v1/listen?encoding=webm-opus&sample_rate=48000&language=nl',
  _maxListeners: undefined,
  outputData: [],
  [Symbol(kCapture)]: false,
  [Symbol(kBytesWritten)]: 0,
  writable: true,
  [Symbol(kNeedDrain)]: false,
  destroyed: true,
  [Symbol(corked)]: 0,
  _last: true,
  chunkedEncoding: false,
  [Symbol(errored)]: null,
  _defaultKeepAlive: true,
  [Symbol(kRejectNonStandardBodyWrites)]: false,
  useChunkedEncodingByDefault: false,
  [Symbol(kUniqueHeaders)]: null,
  sendDate: false,
  [Symbol(kAborted)]: true,
  _removedContLen: false,
},
[Symbol(shapeMode)]: false,
[Symbol(kCapture)]: false

[Symbol(kError)]: Error: Unexpected server response: 400
finished: true,
_headerSent: true,
_closed: false,
at HTTPParser.parserOnIncomingClient (node:_http_client:702:27)
at HTTPParser.parserOnHeadersComplete (node:_http_common:118:17)
at TLSSocket.socketOnData (node:_http_client:544:22)
'Content-Type: application/json\r\n' +
'X-Client-Info: Deepgram/sdk; server; v3.13.0\r\n' +
at readableAddChunkPushByteMode (node:internal/streams/readable:512:3)
at Readable.push (node:internal/streams/readable:392:5)
'Sec-WebSocket-Version: 13\r\n' +
[Symbol(kMessage)]: 'Unexpected server response: 400'

    'Upgrade: websocket\r\n' +

}

    'Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits\r\n' +

Deepgram stream gesloten

tight roseBOT May 20, 2025, 2:18 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

Your backend is receiving a 400 error (Unexpected server response: 400) when trying to connect to Deepgram’s live transcription WebSocket. This means the Deepgram server is rejecting your connection request. Based on the knowledge sources, here are the most likely causes and what you should check:

1. Audio Encoding and Sample Rate Mismatch

A very common cause for a 400 error is a mismatch between the encoding and sample_rate you specify in your Deepgram connection and the actual audio data you send. For example, if you specify encoding=webm-opus&sample_rate=48000, but your client is not actually sending audio in that format and rate, Deepgram will reject the connection [WebSocket Troubleshooting].

Action:
Double-check that your client is sending audio in webm-opus format at 48kHz. If you are using the browser’s MediaRecorder, ensure it is set to record in this format.

2. Unnecessary Encoding Parameter for Containerized Audio

If you are sending containerized audio (like WebM), you do not need to specify the encoding and sample_rate parameters. Deepgram can extract this information from the container. In fact, specifying these parameters for containerized audio can cause a 400 error. This was confirmed in an official answer:

"The encoding parameter is only required for raw audio and needs to be one of the supported options. Since the audio coming through is containerized (WebM), the decoding information does not need to be included, as Deepgram's system will parse the container information (i.e. encoding, sample-rate, and channels)."
Sudden Deepgram Failure - Official Answer

#

Action:
Try removing the encoding and sample_rate parameters from your Deepgram connection if you are sending WebM audio.

3. API Key Issues

A 400 error can also occur if your API key is missing, invalid, or does not have access to the requested language or model [WebSocket Troubleshooting].

Action:
Ensure your API key is valid and has the necessary permissions.

4. Unsupported or Misspelled Parameters

If you provide an unsupported or misspelled option in your Deepgram stream configuration, the server will return a 400 error [WebSocket Troubleshooting].

Action:
Review your Deepgram stream options for typos or unsupported parameters.

Summary of What to Try

If sending WebM audio, remove encoding and sample_rate from your Deepgram connection options.
Double-check your API key and permissions.
Ensure all other parameters are valid and supported.

If you make these changes and still get a 400 error, please share your updated connection code and details about the audio data you are sending.

References integrated above.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

#

@fallow dock Kapa.ai is still learning and improving, please let me know how I did by reacting below.

fallow dock May 20, 2025, 2:26 PM

#

@tight rose now I get 'Unexpected server response: 401'

tight roseBOT May 20, 2025, 2:26 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

A 401 error (Unexpected server response: 401) from Deepgram means "Unauthorized"—your API key is either missing, invalid, or does not have the required permissions.

Based on the knowledge sources, here are the most common causes and solutions:

1. API Key Format

Make sure you are passing the API key in the correct format. For the Deepgram Node SDK, you should initialize the client like this:

const deepgram = createClient({ apiKey: process.env.DEEPGRAM_API_KEY });

If you are using a lower-level WebSocket connection, the Authorization header should be:

Authorization: token YOUR_DEEPGRAM_API_KEY

or

Authorization: Bearer YOUR_JWT_TOKEN

as shown in the official documentation.

2. API Key Validity

Double-check that your API key is correct, not expired, and has the necessary permissions for the requested model and language. Using an invalid or insufficiently privileged key will result in a 401 error [Errors].

3. SDK Version

If you are using an older version of the Deepgram SDK, upgrade to the latest version. There have been cases where older SDKs caused authentication issues, and upgrading resolved the problem [Error in api request in python, 401 Unauthorized error using JS-SDK].

4. Environment Variables

If you are using environment variables, ensure they are loaded correctly and that process.env.DEEPGRAM_API_KEY actually contains your API key.

#

5. No API Key in URL

Do not pass the API key as a query parameter in the URL (e.g., ?token=...). This is not supported for live streaming and will result in a 401 error [Unauthorized (HTTP/1.1 401 Unauthorized) for Streaming Socket Android App].

Summary:
A 401 error means Deepgram is not receiving a valid API key. Double-check your API key, how you are passing it, and ensure you are using the latest SDK. If the problem persists, try generating a new API key from the Deepgram Console and use that.

If you need more help, please share how you are setting and passing your API key in your code.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

#

@fallow dock Kapa.ai is still learning and improving, please let me know how I did by reacting below.

fallow dock May 22, 2025, 2:39 PM

#

@tight rose what is the latest v4 version?

tight roseBOT May 22, 2025, 2:39 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

I'm sorry, but the knowledge sources do not specify the latest v4 version of the Deepgram .NET SDK or any other SDK. The documentation does mention that you can visit the Deepgram NuGet package page for the latest version, but the exact version number is not provided in the sources above. For the most accurate and up-to-date information, please refer to the official package repository or documentation [.NET SDK V3 to V4 Migration Guide].

If you need the latest version number, please check the NuGet page directly.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

#

@fallow dock Kapa.ai is still learning and improving, please let me know how I did by reacting below.

fallow dock May 23, 2025, 9:57 PM

#

@tight rose where can I find a token for my project? Or how can I make a new one

tight roseBOT May 23, 2025, 9:57 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

To get a token (API key) for your Deepgram project, you need to create one in the Deepgram Console. You can sign up for a free account and generate API keys here: Deepgram Console - API Keys 🔑 To access the Deepgram API you will need a free Deepgram API Key.

If you want to create additional or temporary API keys (for example, for client-side use or limited access), you can do so from the same console interface. You can also set expiration dates for keys if needed Does Deepgram API Key expires?.

For more details on creating and managing API keys, see the official documentation: Create Additional API Keys.

If you need to generate a temporary key programmatically (for example, for each client session), you can use the Deepgram SDK’s project key creation endpoint, as discussed here: Client Side API Key.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

#

@fallow dock Kapa.ai is still learning and improving, please let me know how I did by reacting below.

fallow dock May 23, 2025, 10:22 PM

#

@tight rose can we only generate tokens when using a teams project?

tight roseBOT May 23, 2025, 10:22 PM

#

Let me check the knowledge base for you again. One moment! :books:

#

The knowledge sources do not explicitly state that you must be using a "teams project" to generate API tokens (keys) in Deepgram. They indicate that you can create API keys for your project via the Deepgram Console, and there is no mention of this being restricted only to team or organizational accounts. You can generate additional or temporary API keys for your project as needed, and this is a common practice for both individual and team use cases Client Side API Key Create Additional API Keys.

If you need more specific details about account or project requirements, the knowledge sources do not provide that information. If you are unsure, you can check directly in the Deepgram Console or consult the official documentation.

#Live transcription

1. Audio Source

2. Sending Audio Data

3. SDK Usage

4. Example: Microphone to Deepgram (Node/Browser)

Let me know if you need a specific code example for capturing microphone audio in the browser!

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

1. Deepgram SDK Usage

2. Event Handling

3. Common Issues to Check

4. Reference Example

5. Next Steps

Let me know if you need a sample client implementation or have specific error logs to review!

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

1. Audio Encoding and Sample Rate Mismatch

2. Invalid or Unsupported Query Parameters

3. API Key or Permissions

4. Language Detection in Streaming

5. General Debugging Steps

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

1. Audio Encoding and Sample Rate Mismatch

2. Unnecessary Encoding Parameter for Containerized Audio

3. API Key Issues

4. Unsupported or Misspelled Parameters

Summary of What to Try

References integrated above.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

1. API Key Format

2. API Key Validity

3. SDK Version

4. Environment Variables

5. No API Key in URL

If you need more help, please share how you are setting and passing your API key in your code.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

If you need the latest version number, please check the NuGet page directly.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

If you need to generate a temporary key programmatically (for example, for each client session), you can use the Deepgram SDK’s project key creation endpoint, as discussed here: Client Side API Key.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

If you need more specific details about account or project requirements, the knowledge sources do not provide that information. If you are unsure, you can check directly in the Deepgram Console or consult the official documentation.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: