Migrating From Deepgram Flux

This guide covers migrating from Deepgram’s Turn-based Audio (Flux) API. Both Cartesia and Deepgram Flux emit turn-based events over a WebSocket, so migrating to Ink is mostly a matter of renaming fields and updating a few connection parameters.

All migration guides

This guide contains both bare API descriptions and SDK code. To install the SDK:

pip install cartesia

npm i @cartesia/cartesia-js

If you’re already using the Cartesia SDK, upgrade to version >=3.2.0

Ink 2 only supports English right now.
We expect to add more languages in the coming months.

Connection

Replace the Deepgram WebSocket URL and auth header with Cartesia’s.

- wss://api.deepgram.com/v2/listen?model=flux-general-en&encoding=linear16&sample_rate=16000
+ wss://api.cartesia.ai/stt/turns/websocket?model=ink-2&encoding=pcm_s16le&sample_rate=16000

- Authorization: Token <DEEPGRAM_API_KEY>
+ Authorization: Bearer <CARTESIA_API_KEY>
+ Cartesia-Version: 2026-03-01

In browsers, WebSockets do not support request headers. Instead, pass the API version as the cartesia_version query param and use a short-lived access token using the access_token query param instead of an API key. Connect to the turn-detection WebSocket with the Cartesia SDK:

import os
from cartesia import AsyncCartesia

client = AsyncCartesia(api_key=os.getenv("CARTESIA_API_KEY"))

async with client.stt.auto_finalize.websocket(
    model="ink-2", encoding="pcm_s16le", sample_rate=16000
) as connection:
    ...

import os
from cartesia import Cartesia

client = Cartesia(api_key=os.getenv("CARTESIA_API_KEY"))

with client.stt.auto_finalize.websocket(
    model="ink-2", encoding="pcm_s16le", sample_rate=16000
) as connection:
    ...

import Cartesia from "@cartesia/cartesia-js";

const client = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY });

const connection = client.stt.autoFinalize.websocket({
  model: "ink-2",
  encoding: "pcm_s16le",
  sample_rate: 16000,
});

// Server-side: Generate access-tokens using your API key
import Cartesia from '@cartesia/cartesia-js';

const client = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY });

export async function GET() {
  const { token } = await client.accessToken.create({
    grants: { stt: true, tts: false, agent: false },
    // How long the token lasts in seconds
    // Allowed values: 0–3600
    expires_in: 3600,
  });
  return Response.json({ token });
}


// Client-side
// 1. Fetch an access token from your server
// 2. Connect to Cartesia via WebSocket
import Cartesia from "@cartesia/cartesia-js";

async function getToken(): Promise<string> {
  const res = await fetch('/replace-with-your-server');
  const { token } = await res.json();
  return token;
}
const audioContext = new AudioContext();

const client = new Cartesia({ token: await getToken() });

const connection = client.stt.autoFinalize.websocket({
  model: "ink-2",
  encoding: "pcm_f32le",
  sample_rate: audioContext.sampleRate,
});

Query parameters

Deepgram Flux	Cartesia Ink	Notes
`model=flux-general-en` required	`model=ink-2` required	See STT Models for all options.
`encoding=linear16`	`encoding=pcm_s16le` required	See encoding for all options.
`sample_rate`	`sample_rate` required	No change.
`language_hint`	—	Only English is supported right now. Multi-lingual support is coming soon!
—	`cartesia_version=2026-03-01` required	See API Conventions for details.
`eager_eot_threshold`, `eot_threshold`, `eot_timeout_ms`	`turn_eager_end_threshold`, `turn_end_threshold`, `turn_end_timeout_ms`	The thresholds behave differently than Deepgram’s. See turn detection below.
`keyterm`	`keyterm`	See Keyterm prompting.
`mip_opt_out`	—	Controlled by your organization.

encoding

Deepgram	Cartesia
`linear16`	`pcm_s16le`
`linear32`	`pcm_s32le`
`mulaw`	`pcm_mulaw`
`alaw`	`pcm_alaw`
Not supported	`pcm_f16le`
Not supported	`pcm_f32le`
`opus`	Not supported
`ogg-opus`	Not supported

Turn detection

turn_end_timeout_ms is the direct equivalent of eot_timeout_ms. turn_eager_end_threshold and turn_end_threshold offer similar functionality to eager_eot_threshold and eot_threshold, but their directionality is inverted. In Deepgram, higher values require more certainty before firing; in Cartesia, lower values require more certainty before firing. Don’t reuse your Deepgram values directly. See Configuring turn detection for each threshold’s behavior, range, and default.

Sending audio

Both APIs accept raw PCM audio as binary WebSocket frames in the same way.

Cartesia does not support these encodings: opus, ogg-opus

To close the session, send a JSON encoded WebSocket text frame:

- { "type": "CloseStream" }
+ { "type": "close" }

Cartesia has no equivalent of Deepgram’s Configure control message since there’s no need to configure end-of-turn.

# Equivalent to 
# deepgram_connection.send_media(audio_chunk)
await connection.send_raw(audio_chunk)

# Equivalent to
# deepgram_connection.send_close_stream()
await connection.send({"type": "close"})

# Equivalent to 
# deepgram_connection.send_media(audio_chunk)
connection.send_raw(audio_chunk)

# Equivalent to
# deepgram_connection.send_close_stream()
connection.send({"type": "close"})

// Equivalent to deepgramConnection.sendMedia(audioChunk)
// @param {ArrayBufferLike} audioChunk - Note: Blob is not accepted
connection.sendRaw(audioChunk);

// Equivalent to
// deepgramConnection.sendCloseStream({ type: "CloseStream" })
connection.send({ type: "close" });

Event mapping

Deepgram `type`	Cartesia `type`
`Connected`	`connected`
`Error`	`error`
`TurnInfo`	See below

Deepgram wraps all turn events in a single TurnInfo message with an event discriminator. Cartesia emits one message type per event, with the type on the top-level type field.

Deepgram `TurnInfo.event`	Cartesia `type`	Carries `transcript`?
`StartOfTurn`	`turn.start`	No (Deepgram: yes)
`Update`	`turn.update`	Yes
`EagerEndOfTurn`	`turn.eager_end`	Yes
`TurnResumed`	`turn.resume`	No (Deepgram: yes)
`EndOfTurn`	`turn.end`	Yes

A Deepgram TurnInfo message:

{
  "type": "TurnInfo",
  "event": "EndOfTurn",
  "turn_index": 0,
  "transcript": "Hi I need to cancel my subscription please.",
  "words": [...],
  "end_of_turn_confidence": 0.7,
  "audio_window_start": 0.0,
  "audio_window_end": 1.7
}

Becomes a Cartesia turn.* event:

{
  "type": "turn.end",
  "transcript": "Hi I need to cancel my subscription please.",
  "request_id": "2ff8af53-4d38-479d-8287-58940f01c701"
}

Like Deepgram, the transcript is cumulative within a turn.

Event handler

The branching structure of your handler is unchanged — just the message shape.

  ws.onmessage = (message) => {
    const data = JSON.parse(message.data);
-   if (data.type !== "TurnInfo") return;
-   switch (data.event) {
-     case "StartOfTurn":    onTurnStart(); break;
-     case "Update":         onTranscriptUpdate(data.transcript); break;
-     case "EagerEndOfTurn": prepareReply(data.transcript); break;
-     case "TurnResumed":    cancelReply(); break;
-     case "EndOfTurn":      finalizeReply(data.transcript); break;
-   }
+   switch (data.type) {
+     case "turn.start":     onTurnStart(); break;
+     case "turn.update":    onTranscriptUpdate(data.transcript); break;
+     case "turn.eager_end": prepareReply(data.transcript); break;
+     case "turn.resume":    cancelReply(); break;
+     case "turn.end":       finalizeReply(data.transcript); break;
+   }
  };

import asyncio
from cartesia.types.stt import STTAutoFinalizeWebsocketResponse

def on_message(message: STTAutoFinalizeWebsocketResponse) -> None:
    if message.type == "turn.start":
        print("StartOfTurn")
    elif message.type == "turn.update":
        print(f"Update: {message.transcript}")
    elif message.type == "turn.eager_end":
        print(f"EagerEndOfTurn: {message.transcript}")
    elif message.type == "turn.resume":
        print("TurnResumed")
    elif message.type == "turn.end":
        print(f"EndOfTurn: {message.transcript}")
    elif message.type == "error":
        print(f"Error: {message.message}")

# Equivalent to
# deepgram_connection.on(EventType.MESSAGE, on_message)
connection.on("event", on_message)

# Equivalent to
# asyncio.create_task(deepgram_connection.start_listening())
recv_task = asyncio.create_task(connection.dispatch_events())

import threading
from cartesia.types.stt import STTAutoFinalizeWebsocketResponse

def on_message(message: STTAutoFinalizeWebsocketResponse) -> None:
    if message.type == "turn.start":
        print("StartOfTurn")
    elif message.type == "turn.update":
        print(f"Update: {message.transcript}")
    elif message.type == "turn.eager_end":
        print(f"EagerEndOfTurn: {message.transcript}")
    elif message.type == "turn.resume":
        print("TurnResumed")
    elif message.type == "turn.end":
        print(f"EndOfTurn: {message.transcript}")
    elif message.type == "error":
        print(f"Error: {message.message}")

# Equivalent to
# deepgram_connection.on(EventType.MESSAGE, on_message)
connection.on("event", on_message)

# Equivalent to
# threading.Thread(target=deepgram_connection.start_listening, daemon=True).start()
threading.Thread(target=connection.dispatch_events, daemon=True).start()

import Cartesia from '@cartesia/cartesia-js';

// Equivalent to
// deepgramConnection.on("message", (message) => { ... });
connection.on("event", (message: Cartesia.STT.AutoFinalize.STTAutoFinalizeWebsocketResponse) => {
  switch (message.type) {
    case "turn.start":
      console.log("StartOfTurn");
      break;
    case "turn.update":
      console.log(`Update: ${message.transcript}`);
      break;
    case "turn.eager_end":
      console.log(`EagerEndOfTurn: ${message.transcript}`);
      break;
    case "turn.resume":
      console.log("TurnResumed");
      break;
    case "turn.end":
      console.log(`EndOfTurn: ${message.transcript}`);
      break;
  }
});

// Equivalent to
// deepgramConnection.on("error", (error) => { ... });
connection.on("error", (error) => {
  if (error.error) {
    // Server sent error (may be a bad request or internal server error)
    console.error(`Server sent an error: ${error.error.message}`);
  } else {
    // Client error
    console.error(`Client had an error: ${error.message}`);
  }
});

Example Server Messages

Flux’s transcripts are joined with spaces. Ink’s are not.

Deepgram Flux	Cartesia Realtime STT (Auto)
StartOfTurn	turn.start
Update `"Flux's transcripts"`	turn.update `"Flux's transcripts"`
EagerEndOfTurn `"Flux's transcripts"`	turn.eager_end `"Flux's transcripts"`
TurnResumed	turn.resume
Update `"Flux's transcripts are joined with spaces."`	turn.update `"Flux's transcripts are joined with spaces."`
EagerEndOfTurn `"Flux's transcripts are joined with spaces."`	turn.eager_end `"Flux's transcripts are joined with spaces."`
EndOfTurn `"Flux's transcripts are joined with spaces."`	turn.end `"Flux's transcripts are joined with spaces."`
StartOfTurn	turn.start
Update `"Ink's are not."`	turn.update `" Ink's are not."`
EagerEndOfTurn `"Ink's are not."`	turn.eager_end `" Ink's are not."`
EndOfTurn `"Ink's are not."`	turn.end `" Ink's are not."`

Get Started

Text-to-Speech

Speech-to-Text

Tools

Integrations

Enterprise

Migrating From Deepgram Flux

All migration guides

Connection

Query parameters

Turn detection

Sending audio

Event mapping

Event handler

Example Server Messages

References

API Reference

Full Code Example

All migration guides

​Connection

​Query parameters

​Turn detection

​Sending audio

​Event mapping

​Event handler

​Example Server Messages

​References

API Reference

Full Code Example

Connection

Query parameters

Turn detection

Sending audio

Event mapping

Event handler

Example Server Messages

References