> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# JavaScript SDK

> **Info**
>
> Scribe और इसकी क्षमताओं के ओवरव्यू के लिए, [स्पीच टू टेक्स्ट ओवरव्यू](/docs/hi/capabilities/speech-to-text) देखें। चरण-दर-चरण उपयोग गाइड के लिए, [क्लाइंट-साइड स्ट्रीमिंग](/docs/hi/eleven-api/guides/how-to/speech-to-text/realtime/client-side-streaming) देखें।

## इंस्टॉलेशन

```shell
npm install @elevenlabs/client
# or
yarn add @elevenlabs/client
# or
pnpm install @elevenlabs/client
```

> **Tip**
>
> अपने AI कोडिंग असिस्टेंट से ऑडियो ट्रांसक्राइब करने के लिए [ElevenLabs स्पीच-टू-टेक्स्ट स्किल](https://github.com/elevenlabs/skills/tree/main/speech-to-text) का इस्तेमाल करें:
>
> ```bash
> npx skills add elevenlabs/skills --skill speech-to-text
> ```

> **Note**
>
> इस लाइब्रेरी का इस्तेमाल किसी भी JavaScript-आधारित प्रोजेक्ट में किया जा सकता है। अगर आप React इस्तेमाल कर रहे हैं, तो
> [`useScribe` हुक](/docs/hi/eleven-api/resources/libraries/scribe-stt/react-scribe) पर विचार करें, जो
> बिल्ट-इन स्टेट मैनेजमेंट और लाइफसाइकल हैंडलिंग देता है।

## उपयोग

यहां एक न्यूनतम काम करने वाला उदाहरण है, जो Scribe से कनेक्ट होता है और ट्रांसक्रिप्शन नतीजे लॉग करता है:

```js
import { Scribe, RealtimeEvents } from "@elevenlabs/client";

const token = await fetchTokenFromServer();

const connection = Scribe.connect({
  token,
  modelId: "scribe_v2_realtime",
  microphone: {
    echoCancellation: true,
    noiseSuppression: true,
  },
});

connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
  console.log("Partial:", data.text);
});

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

// Later, close the connection
connection.close();
```

## टोकन पाना

Scribe को ऑथेंटिकेशन के लिए सिंगल-यूज़ टोकन चाहिए। अपने सर्वर पर एक API एंडपॉइंट बनाएं:

```js
// Node.js server
app.get("/scribe-token", yourAuthMiddleware, async (req, res) => {
  const response = await fetch("https://api.elevenlabs.io/v1/single-use-token/realtime_scribe", {
    method: "POST",
    headers: {
      "xi-api-key": process.env.ELEVENLABS_API_KEY,
    },
  });

  const data = await response.json();
  res.json({ token: data.token });
});
```

> **Warning**
>
> आपकी ElevenLabs API कुंजी संवेदनशील है। इसे कभी क्लाइंट को न दिखाएं। टोकन हमेशा
> सर्वर पर जनरेट करें।

```js
// Client
const fetchToken = async () => {
  const response = await fetch("/scribe-token");
  const { token } = await response.json();
  return token;
};
```

## कनेक्शन विकल्प

`Scribe.connect()` माइक्रोफ़ोन विकल्प या मैन्युअल ऑडियो विकल्प स्वीकार करता है। दोनों में बेस विकल्पों का एक सामान्य सेट होता है।

### बेस विकल्प

| प्रॉपर्टी                   | टाइप             | डिफ़ॉल्ट                    | विवरण                                                                                |
| --------------------------- | ---------------- | --------------------------- | ------------------------------------------------------------------------------------ |
| **token**                   | `string`         |                             | WebSocket ऑथेंटिकेशन के लिए सिंगल-यूज़ टोकन।                                         |
| **modelId**                 | `string`         |                             | मॉडल ID (जैसे, `"scribe_v2_realtime"`)।                                              |
| **baseUri**                 | `string`         | `"wss://api.elevenlabs.io"` | कस्टम WebSocket बेस URI।                                                             |
| **commitStrategy**          | `CommitStrategy` | `"manual"`                  | `"manual"` या `"vad"`।                                                               |
| **vadSilenceThresholdSecs** | `number`         | `1.5`                       | VAD कमिट करने से पहले की चुप्पी के सेकंड (0.3-3.0)।                                  |
| **vadThreshold**            | `number`         | `0.4`                       | VAD संवेदनशीलता (0.1-0.9, कम मान ज़्यादा संवेदनशील होता है)।                         |
| **minSpeechDurationMs**     | `number`         | `100`                       | ms में न्यूनतम बोलने की अवधि (50-2000)।                                              |
| **minSilenceDurationMs**    | `number`         | `100`                       | ms में न्यूनतम चुप्पी की अवधि (50-2000)।                                             |
| **languageCode**            | `string`         |                             | ISO-639-1 या ISO-639-3 भाषा कोड। ऑटो-डिटेक्शन के लिए खाली छोड़ें।                    |
| **includeTimestamps**       | `boolean`        | `false`                     | `COMMITTED_TRANSCRIPT_WITH_TIMESTAMPS` इवेंट के ज़रिए शब्द-स्तर के टाइमस्टैम्प पाएं। |

### माइक्रोफ़ोन विकल्प

यूज़र के माइक्रोफ़ोन से सीधे ऑडियो स्ट्रीम करने के लिए `microphone` ऑब्जेक्ट पास करें। कनेक्शन `getUserMedia` और ऑडियो एन्कोडिंग को अपने-आप हैंडल करता है।

```js
const connection = Scribe.connect({
  token,
  modelId: "scribe_v2_realtime",
  microphone: {
    deviceId: "optional-device-id",
    echoCancellation: true,
    noiseSuppression: true,
    autoGainControl: true,
  },
});
```

| प्रॉपर्टी            | टाइप      | विवरण                           |
| -------------------- | --------- | ------------------------------- |
| **deviceId**         | `string`  | खास माइक्रोफ़ोन डिवाइस ID।      |
| **echoCancellation** | `boolean` | इको कैंसलेशन चालू करें।         |
| **noiseSuppression** | `boolean` | नॉइज़ सप्रेशन चालू करें।        |
| **autoGainControl**  | `boolean` | ऑटोमैटिक गेन कंट्रोल चालू करें। |

### मैन्युअल ऑडियो विकल्प

`connection.send()` के ज़रिए मैन्युअली ऑडियो डेटा भेजने के लिए `audioFormat` और `sampleRate` पास करें।

```js
import { AudioFormat } from "@elevenlabs/client";

const connection = Scribe.connect({
  token,
  modelId: "scribe_v2_realtime",
  audioFormat: AudioFormat.PCM_16000,
  sampleRate: 16000,
});
```

| प्रॉपर्टी       | टाइप          | विवरण                                                     |
| --------------- | ------------- | --------------------------------------------------------- |
| **audioFormat** | `AudioFormat` | ऑडियो एन्कोडिंग फ़ॉर्मैट (जैसे, `AudioFormat.PCM_16000`)। |
| **sampleRate**  | `number`      | Hz में सैंपल रेट। यह `audioFormat` से मेल खाना चाहिए।     |

#### AudioFormat enum

```typescript
enum AudioFormat {
  PCM_8000 = "pcm_8000",
  PCM_16000 = "pcm_16000",
  PCM_22050 = "pcm_22050",
  PCM_24000 = "pcm_24000",
  PCM_44100 = "pcm_44100",
  PCM_48000 = "pcm_48000",
  ULAW_8000 = "ulaw_8000",
}
```

## माइक्रोफ़ोन मोड

यूज़र के माइक्रोफ़ोन से सीधे ऑडियो स्ट्रीम करें:

```js
import { Scribe, RealtimeEvents } from "@elevenlabs/client";

async function transcribeFromMicrophone() {
  const token = await fetchToken();

  const connection = Scribe.connect({
    token,
    modelId: "scribe_v2_realtime",
    microphone: {
      echoCancellation: true,
      noiseSuppression: true,
      autoGainControl: true,
    },
  });

  connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
    document.getElementById("live").textContent = data.text;
  });

  connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
    const el = document.createElement("p");
    el.textContent = data.text;
    document.getElementById("transcripts").appendChild(el);
    document.getElementById("live").textContent = "";
  });

  document.getElementById("stop").addEventListener("click", () => {
    connection.close();
  });
}
```

## मैन्युअल ऑडियो मोड (फ़ाइल ट्रांसक्रिप्शन)

ऑडियो डेटा मैन्युअली भेजकर पहले से रिकॉर्ड की गई ऑडियो फ़ाइलों को ट्रांसक्राइब करें:

```js
import { Scribe, RealtimeEvents, AudioFormat } from "@elevenlabs/client";

async function transcribeFile(file) {
  const token = await fetchToken();

  const connection = Scribe.connect({
    token,
    modelId: "scribe_v2_realtime",
    audioFormat: AudioFormat.PCM_16000,
    sampleRate: 16000,
  });

  connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
    console.log("Transcript:", data.text);
  });

  // Decode audio file
  const arrayBuffer = await file.arrayBuffer();
  const audioContext = new AudioContext({ sampleRate: 16000 });
  const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);

  // Convert to PCM16
  const channelData = audioBuffer.getChannelData(0);
  const pcmData = new Int16Array(channelData.length);

  for (let i = 0; i < channelData.length; i++) {
    const sample = Math.max(-1, Math.min(1, channelData[i]));
    pcmData[i] = sample < 0 ? sample * 32768 : sample * 32767;
  }

  // Send in chunks
  const chunkSize = 4096;
  for (let offset = 0; offset < pcmData.length; offset += chunkSize) {
    const chunk = pcmData.slice(offset, offset + chunkSize);
    const bytes = new Uint8Array(chunk.buffer);
    const base64 = btoa(String.fromCharCode(...bytes));

    connection.send({ audioBase64: base64 });
    await new Promise((resolve) => setTimeout(resolve, 50));
  }

  // Commit and close
  connection.commit();
}
```

## RealtimeConnection

`Scribe.connect()` निम्नलिखित मेथड वाला `RealtimeConnection` इंस्टेंस लौटाता है।

### on(event, listener)

इवेंट लिस्नर रजिस्टर करें। उपलब्ध इवेंट टाइप के लिए [इवेंट्स](#events) देखें।

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

### off(event, listener)

पहले से रजिस्टर किया गया इवेंट लिस्नर हटाएं।

```js
const handler = (data) => console.log(data.text);
connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, handler);

// Later
connection.off(RealtimeEvents.COMMITTED_TRANSCRIPT, handler);
```

### send(data)

Scribe को ऑडियो डेटा भेजें (सिर्फ़ मैन्युअल ऑडियो मोड में)।

```js
connection.send({
  audioBase64: base64AudioChunk,
  commit: false, // Optional: commit immediately
  sampleRate: 16000, // Optional: override sample rate
  previousText: "Previous transcription text", // Optional: context from a previous transcription
});
```

> **Warning**
>
> `previousText` फ़ील्ड सिर्फ़ सेशन के पहले ऑडियो चंक में भेजा जा सकता है। इसे
> बाद के चंक्स में भेजने पर एरर आता है।

### commit()

मौजूदा ट्रांसक्रिप्शन को मैन्युअली कमिट करें। इसकी ज़रूरत सिर्फ़ `CommitStrategy.MANUAL` इस्तेमाल करते समय होती है।

```js
connection.commit();
```

### close()

WebSocket कनेक्शन बंद करें और रिसोर्स (माइक्रोफ़ोन स्ट्रीम, ऑडियो कॉन्टेक्स्ट) साफ़ करें।

```js
connection.close();
```

## इवेंट्स

`connection.on(event, listener)` का इस्तेमाल करके इवेंट लिस्नर रजिस्टर करें। सभी इवेंट `RealtimeEvents` enum पर कॉन्स्टेंट के रूप में उपलब्ध हैं।

### ट्रांसक्रिप्शन इवेंट्स

| इवेंट                                    | डेटा                                                            | विवरण                               |
| ---------------------------------------- | --------------------------------------------------------------- | ----------------------------------- |
| **SESSION_STARTED**                      | `{ session_id: string }`                                        | Scribe सेशन शुरू हुआ।               |
| **PARTIAL_TRANSCRIPT**                   | `{ text: string }`                                              | अंतरिम ट्रांसक्रिप्शन नतीजा।        |
| **COMMITTED_TRANSCRIPT**                 | `{ text: string }`                                              | अंतिम ट्रांसक्रिप्शन नतीजा।         |
| **COMMITTED_TRANSCRIPT_WITH_TIMESTAMPS** | `{ text: string; language_code?: string; words?: WordsItem[] }` | शब्द-स्तर टाइमिंग वाला अंतिम नतीजा। |

`WordsItem` टाइप में शब्द-स्तर की टाइमिंग जानकारी होती है:

```typescript
interface WordsItem {
  text?: string; // Word text
  start?: number; // Start time in seconds
  end?: number; // End time in seconds
  type?: "word" | "spacing"; // Token type
  speaker_id?: string; // Speaker identifier
}
```

### कनेक्शन इवेंट्स

| इवेंट     | डेटा             | विवरण                      |
| --------- | ---------------- | -------------------------- |
| **OPEN**  | `Event`          | WebSocket कनेक्शन खुला।    |
| **CLOSE** | `Event`          | WebSocket कनेक्शन बंद हुआ। |
| **ERROR** | `Error \| Event` | सामान्य एरर।               |

### एरर इवेंट्स

सभी एरर इवेंट्स को `{ error: string }` मिलता है।

| इवेंट                           | विवरण                                                    |
| ------------------------------- | -------------------------------------------------------- |
| **AUTH_ERROR**                  | ऑथेंटिकेशन एरर।                                          |
| **QUOTA_EXCEEDED**              | उपयोग कोटा पार हो गया।                                   |
| **COMMIT_THROTTLED**            | कमिट अनुरोध थ्रॉटल किया गया।                             |
| **TRANSCRIBER_ERROR**           | ट्रांसक्रिप्शन इंजन एरर।                                 |
| **UNACCEPTED_TERMS**            | सेवा की शर्तें स्वीकार नहीं की गईं।                      |
| **RATE_LIMITED**                | रेट लिमिट लागू है।                                       |
| **INPUT_ERROR**                 | अमान्य इनपुट फ़ॉर्मैट।                                   |
| **QUEUE_OVERFLOW**              | प्रोसेसिंग क्यू भर गई है।                                |
| **RESOURCE_EXHAUSTED**          | सर्वर रिसोर्स क्षमता पर हैं।                             |
| **SESSION_TIME_LIMIT_EXCEEDED** | अधिकतम सेशन समय पूरा हो गया।                             |
| **CHUNK_SIZE_EXCEEDED**         | ऑडियो चंक बहुत बड़ा है।                                  |
| **INSUFFICIENT_AUDIO_ACTIVITY** | कनेक्शन बनाए रखने के लिए पर्याप्त ऑडियो गतिविधि नहीं है। |

## कमिट रणनीतियां

ट्रांसक्रिप्शन कब कमिट हों, इसे नियंत्रित करें:

```js
import { Scribe, CommitStrategy } from '@elevenlabs/client';

// Manual (default): you control when to commit
const connection = Scribe.connect({
  token,
  modelId: 'scribe_v2_realtime',
  audioFormat: AudioFormat.PCM_16000,
  sampleRate: 16000,
  commitStrategy: CommitStrategy.MANUAL,
});

// Send audio, then commit when ready
connection.send({ audioBase64: chunk });
connection.commit();

// Voice Activity Detection: Scribe detects silences and commits automatically
const connection = Scribe.connect({
  token,
  modelId: 'scribe_v2_realtime',
  microphone: { echoCancellation: true },
  commitStrategy: CommitStrategy.VAD,
});
```

ज़्यादा जानकारी के लिए, [ट्रांसक्रिप्ट और कमिट रणनीतियां](/docs/hi/eleven-api/guides/how-to/speech-to-text/realtime/transcripts-and-commit-strategies) देखें।

## पूरा उदाहरण

यहां VAD-आधारित कमिट रणनीति के साथ माइक्रोफ़ोन ऑडियो ट्रांसक्राइब करने का पूरा उदाहरण है:

```js
import { Scribe, RealtimeEvents, CommitStrategy } from "@elevenlabs/client";

async function startTranscription() {
  const token = await fetchToken();

  const connection = Scribe.connect({
    token,
    modelId: "scribe_v2_realtime",
    commitStrategy: CommitStrategy.VAD,
    microphone: {
      echoCancellation: true,
      noiseSuppression: true,
    },
  });

  connection.on(RealtimeEvents.SESSION_STARTED, (data) => {
    console.log("Session started:", data.session_id);
  });

  connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, (data) => {
    document.getElementById("live").textContent = data.text;
  });

  connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, (data) => {
    const el = document.createElement("p");
    el.textContent = data.text;
    document.getElementById("transcripts").appendChild(el);
    document.getElementById("live").textContent = "";
  });

  connection.on(RealtimeEvents.ERROR, (error) => {
    console.error("Scribe error:", error);
  });

  // Stop button
  document.getElementById("stop").addEventListener("click", () => {
    connection.close();
  });
}

document.getElementById("start").addEventListener("click", startTranscription);
```