Migrating from ElevenLabs with Automatic Commits

pip install cartesia

npm i @cartesia/cartesia-js

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 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,
});

# ElevenLabs
await elevenlabs_connection.send({
  "audio_base_64": b64encode(raw_audio),
})

# Cartesia
# raw_audio (bytes) - Raw audio data, about 100 ms at a time
await connection.send_raw(raw_audio)

// ElevenLabs
elevenLabsConnection.send({ audioBase64: rawAudio.toBase64() });

// Cartesia
// @param {ArrayBufferLike} rawAudio - raw audio data, about 100 ms at a time
connection.sendRaw(rawAudio);

# ElevenLabs
await elevenlabs_connection.send({
  "audio_base_64": audio_base_64,
})

# Cartesia
from base64 import b64decode
await connection.send_raw(b64decode(audio_base_64))

// ElevenLabs
elevenLabsConnection.send({ audioBase64 });

// Cartesia
connection.sendRaw(Uint8Array.fromBase64(audioBase64));

# ElevenLabs
elevenlabs_connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, lambda: elevenlabs_connection.close())
await elevenlabs_connection.commit()

# Cartesia
await connection.send({"type": "close"})

# Cartesia: Close the socket early (optional)
await connection.close()

// ElevenLabs
elevenLabsConnection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, () => elevenLabsConnection.close());
elevenLabsConnection.commit();

// Cartesia
connection.send({ type: "close" });

// Cartesia: Close the socket early (optional)
connection.close();

import asyncio
from cartesia.types.stt import STTAutoFinalizeWebsocketResponse

def on_message(message: STTAutoFinalizeWebsocketResponse) -> None:
    if message.type == "turn.start":
        print("User started speaking")
    elif message.type == "turn.update":
        print(f"partial_transcript: {message.transcript}")
    elif message.type == "turn.end":
        print(f"committed_transcript: {message.transcript}")
    elif message.type == "error":
        error_code = message.error_code or "unknown_error"
        if error_code == "quota_exceeded":
            print("You are out of credits")
        elif error_code == "concurrency_limited":
            print("You have too many open STT connections")
        else:
            print(f"{error_code}: {message.message}")

connection.on("event", on_message)

# ElevenLabs dispatches to your callbacks automatically;
# with Cartesia you run the dispatch loop yourself
recv_task = asyncio.create_task(connection.dispatch_events())

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

connection.on("event", (message: Cartesia.STT.AutoFinalize.STTAutoFinalizeWebsocketResponse) => {
  switch (message.type) {
    case "turn.start":
      console.log("User started speaking");
      break;
    case "turn.update":
      console.log(`partial_transcript: ${message.transcript}`);
      break;
    case "turn.end":
      console.log(`committed_transcript: ${message.transcript}`);
      break;
  }
});

connection.on("error", (error) => {
  if (error.error) {
    // Server sent error (may be a bad request or internal server error)
    const errorCode = error.error.error_code || "unknown_error";
    switch (errorCode) {
      case "quota_exceeded":
        console.error("You are out of credits");
        break;
      case "concurrency_limited":
        console.error("You have too many open STT connections");
        break;
      default:
        console.error(`${errorCode}: ${error.error.message}`);
        break;
    }
  } else {
    // Client error
    console.error(`Client had an error: ${error.message}`);
  }
});

connection.on("close", (code: number, reason: string) => {
  if (code === 1001) {
    console.log("WebSocket closed due to inactivity");
  } else {
    console.log(`WebSocket closed (${code}): ${reason}`);
  }
});