JavaScript SDK

1
import { Scribe, RealtimeEvents } from "@elevenlabs/client";
2
3
const token = await fetchTokenFromServer();
4
5
const connection = Scribe.connect({
6
  token,
7
  modelId: "scribe_v2_realtime",
8
  microphone: {
9
    echoCancellation: true,
10
    noiseSuppression: true,
11
  },
12
});
13
14
connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
15
  console.log("Partial:", data.text);
16
});
17
18
connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
19
  console.log("Committed:", data.text);
20
});
21
22
// Later, close the connection
23
connection.close();

1
// Node.js server
2
app.get("/scribe-token", yourAuthMiddleware, async (req, res) => {
3
  const response = await fetch("https://api.elevenlabs.io/v1/single-use-token/realtime_scribe", {
4
    method: "POST",
5
    headers: {
6
      "xi-api-key": process.env.ELEVENLABS_API_KEY,
7
    },
8
  });
9
10
  const data = await response.json();
11
  res.json({ token: data.token });
12
});

1
// Client
2
const fetchToken = async () => {
3
  const response = await fetch("/scribe-token");
4
  const { token } = await response.json();
5
  return token;
6
};

1
const connection = Scribe.connect({
2
  token,
3
  modelId: "scribe_v2_realtime",
4
  microphone: {
5
    deviceId: "optional-device-id",
6
    echoCancellation: true,
7
    noiseSuppression: true,
8
    autoGainControl: true,
9
  },
10
});

1
import { AudioFormat } from "@elevenlabs/client";
2
3
const connection = Scribe.connect({
4
  token,
5
  modelId: "scribe_v2_realtime",
6
  audioFormat: AudioFormat.PCM_16000,
7
  sampleRate: 16000,
8
});

1
import { Scribe, RealtimeEvents } from "@elevenlabs/client";
2
3
async function transcribeFromMicrophone() {
4
  const token = await fetchToken();
5
6
  const connection = Scribe.connect({
7
    token,
8
    modelId: "scribe_v2_realtime",
9
    microphone: {
10
      echoCancellation: true,
11
      noiseSuppression: true,
12
      autoGainControl: true,
13
    },
14
  });
15
16
  connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
17
    document.getElementById("live").textContent = data.text;
18
  });
19
20
  connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
21
    const el = document.createElement("p");
22
    el.textContent = data.text;
23
    document.getElementById("transcripts").appendChild(el);
24
    document.getElementById("live").textContent = "";
25
  });
26
27
  document.getElementById("stop").addEventListener("click", () => {
28
    connection.close();
29
  });
30
}

1
import { Scribe, RealtimeEvents, AudioFormat } from "@elevenlabs/client";
2
3
async function transcribeFile(file) {
4
  const token = await fetchToken();
5
6
  const connection = Scribe.connect({
7
    token,
8
    modelId: "scribe_v2_realtime",
9
    audioFormat: AudioFormat.PCM_16000,
10
    sampleRate: 16000,
11
  });
12
13
  connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
14
    console.log("Transcript:", data.text);
15
  });
16
17
  // Decode audio file
18
  const arrayBuffer = await file.arrayBuffer();
19
  const audioContext = new AudioContext({ sampleRate: 16000 });
20
  const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
21
22
  // Convert to PCM16
23
  const channelData = audioBuffer.getChannelData(0);
24
  const pcmData = new Int16Array(channelData.length);
25
26
  for (let i = 0; i < channelData.length; i++) {
27
    const sample = Math.max(-1, Math.min(1, channelData[i]));
28
    pcmData[i] = sample < 0 ? sample * 32768 : sample * 32767;
29
  }
30
31
  // Send in chunks
32
  const chunkSize = 4096;
33
  for (let offset = 0; offset < pcmData.length; offset += chunkSize) {
34
    const chunk = pcmData.slice(offset, offset + chunkSize);
35
    const bytes = new Uint8Array(chunk.buffer);
36
    const base64 = btoa(String.fromCharCode(...bytes));
37
38
    connection.send({ audioBase64: base64 });
39
    await new Promise((resolve) => setTimeout(resolve, 50));
40
  }
41
42
  // Commit and close
43
  connection.commit();
44
}

1
connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
2
  console.log("Committed:", data.text);
3
});

1
const handler = (data) => console.log(data.text);
2
connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, handler);
3
4
// Later
5
connection.off(RealtimeEvents.COMMITTED_TRANSCRIPT, handler);

1
connection.send({
2
  audioBase64: base64AudioChunk,
3
  commit: false, // Optional: commit immediately
4
  sampleRate: 16000, // Optional: override sample rate
5
  previousText: "Previous transcription text", // Optional: context from a previous transcription
6
});

1
connection.commit();

1
connection.close();

1
import { Scribe, CommitStrategy } from '@elevenlabs/client';
2
3
// Manual (default): you control when to commit
4
const connection = Scribe.connect({
5
  token,
6
  modelId: 'scribe_v2_realtime',
7
  audioFormat: AudioFormat.PCM_16000,
8
  sampleRate: 16000,
9
  commitStrategy: CommitStrategy.MANUAL,
10
});
11
12
// Send audio, then commit when ready
13
connection.send({ audioBase64: chunk });
14
connection.commit();
15
16
// Voice Activity Detection: Scribe detects silences and commits automatically
17
const connection = Scribe.connect({
18
  token,
19
  modelId: 'scribe_v2_realtime',
20
  microphone: { echoCancellation: true },
21
  commitStrategy: CommitStrategy.VAD,
22
});

1
import { Scribe, RealtimeEvents, CommitStrategy } from "@elevenlabs/client";
2
3
async function startTranscription() {
4
  const token = await fetchToken();
5
6
  const connection = Scribe.connect({
7
    token,
8
    modelId: "scribe_v2_realtime",
9
    commitStrategy: CommitStrategy.VAD,
10
    microphone: {
11
      echoCancellation: true,
12
      noiseSuppression: true,
13
    },
14
  });
15
16
  connection.on(RealtimeEvents.SESSION_STARTED, (data) => {
17
    console.log("Session started:", data.session_id);
18
  });
19
20
  connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
21
    document.getElementById("live").textContent = data.text;
22
  });
23
24
  connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
25
    const el = document.createElement("p");
26
    el.textContent = data.text;
27
    document.getElementById("transcripts").appendChild(el);
28
    document.getElementById("live").textContent = "";
29
  });
30
31
  connection.on(RealtimeEvents.ERROR, (error) => {
32
    console.error("Scribe error:", error);
33
  });
34
35
  // Stop button
36
  document.getElementById("stop").addEventListener("click", () => {
37
    connection.close();
38
  });
39
}
40
41
document.getElementById("start").addEventListener("click", startTranscription);