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