> 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.

# एसिंक्रोनस स्पीच टू टेक्स्ट

> **Note**
>
> **कैसे करें गाइड** · मानता है कि आपने [स्पीच टू टेक्स्ट क्विकस्टार्ट](/docs/hi/eleven-api/guides/cookbooks/speech-to-text) पूरा कर लिया है।

## खास जानकारी

वेबहुक्स आपको स्पीच टू टेक्स्ट ट्रांसक्रिप्शन टास्क पूरे होने पर अपने-आप नोटिफ़िकेशन पाने देते हैं, जिससे स्टेटस अपडेट के लिए API को लगातार पोल करने की ज़रूरत नहीं रहती। यह खास तौर पर लंबे समय तक चलने वाले ट्रांसक्रिप्शन जॉब्स या बड़ी संख्या में ऑडियो फ़ाइलों को प्रोसेस करते समय उपयोगी है।

ट्रांसक्रिप्शन पूरा होने पर, ElevenLabs ट्रांसक्रिप्ट टेक्स्ट, भाषा पहचान और किसी भी मेटाडेटा समेत ट्रांसक्रिप्शन नतीजों के साथ आपके दिए गए वेबहुक URL पर POST रिक्वेस्ट भेजेगा।

## वेबहुक्स का इस्तेमाल

> **Note**
>
> यह गाइड मानती है कि आपने [अपनी API key और SDK सेट अप कर ली है](/docs/hi/eleven-api/quickstart)। अगर नहीं की है,
> तो पहले क्विकस्टार्ट पूरा करें।

#### वेबहुक बनाएं या एडिट करें

ElevenLabs डैशबोर्ड में
[**डेवलपर्स** > **वेबहुक्स**](https://elevenlabs.io/app/developers/webhooks) पर जाएं।
**वेबहुक बनाएं** पर क्लिक करें या किसी मौजूदा वेबहुक को एडिट करें।

![Transcription completed चुने हुए वेबहुक बनाने का डायलॉग](/docs/_fern-img/866f389106e74e16586a4d68cf8160f2d27568518ff4f984c2fab81cbd1674c9.webp)

वेबहुक को इन सेटिंग्स के साथ कॉन्फ़िगर करें:

* **नाम**: आपके वेबहुक के लिए एक वर्णनात्मक नाम
* **कॉलबैक URL**: आपका सार्वजनिक रूप से उपलब्ध HTTPS एंडपॉइंट
* **वेबहुक Auth Method**: `HMAC` या `OAuth` में से कोई एक। वेरिफ़िकेशन मैकेनिज़्म लागू करना क्लाइंट की ज़िम्मेदारी है। ElevenLabs ऐसे हेडर्स भेजता है जो वेरिफ़िकेशन की सुविधा देते हैं, लेकिन हम इसे लागू नहीं कराते।
* **इवेंट्स**: **Transcription completed** चुनें।

#### वेबहुक पैरामीटर चालू करके API कॉल करें

स्पीच-टू-टेक्स्ट API कॉल करते समय, उस खास रिक्वेस्ट के लिए वेबहुक नोटिफ़िकेशन चालू करने हेतु `webhook` पैरामीटर को `true` पर सेट करें।

```python maxLines=0
from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

load_dotenv()

elevenlabs = ElevenLabs(
  api_key=os.getenv("ELEVENLABS_API_KEY"),
)

def transcribe_with_webhook(audio_file):
  try:
    result = elevenlabs.speech_to_text.convert(
      file=audio_file,
      model_id="scribe_v2",
      webhook=True,
    )
    print(f"Transcription started: {result.request_id}")
    return result
  except Exception as e:
    print(f"Error starting transcription: {e}")
    raise e
```

```typescript maxLines=0
import { ElevenLabsClient } from '@elevenlabs/elevenlabs-js';

const elevenlabs = new ElevenLabsClient({
  apiKey: process.env.ELEVENLABS_API_KEY,
});

async function transcribeWithWebhook(audioFile) {
  try {
    const result = await elevenlabs.speechToText.convert({
      file: audioFile,
      modelId: 'scribe_v2',
      webhook: true,
    });

    console.log('Transcription started:', result.requestId);
    return result;
  } catch (error) {
    console.error('Error starting transcription:', error);
    throw error;
  }
}
```

## वेबहुक पेलोड

ट्रांसक्रिप्शन पूरा होने पर, आपके वेबहुक एंडपॉइंट को ट्रांसक्रिप्शन और वेबहुक डेटा के साथ POST रिक्वेस्ट मिलेगी:

```json
{
  type: 'speech_to_text_transcription',
  data: {
    request_id: 'some-request-id-123',
    webhook_metadata: { ... }, // if provided in the convert request
    transcription: {
      "language_code": "en",
      "language_probability": 0.98,
      "text": "Hello world!",
      "words": [
        {
          "text": "Hello",
          "start": 0.0,
          "end": 0.5,
          "type": "word",
          "speaker_id": "speaker_1"
        },
        {
          "text": " ",
          "start": 0.5,
          "end": 0.5,
          "type": "spacing",
          "speaker_id": "speaker_1"
        },
        {
          "text": "world!",
          "start": 0.5,
          "end": 1.2,
          "type": "word",
          "speaker_id": "speaker_1"
        }
      ]
    }
  }
}
```

रिस्पॉन्स स्ट्रक्चर की जानकारी के लिए [स्पीच-टू-टेक्स्ट API](/docs/hi/api-reference/speech-to-text/v-1-speech-to-text-realtime) रेफरेंस देखें।

अगर रिक्वेस्ट में [`transcript_edit`](/docs/hi/eleven-api/guides/how-to/speech-to-text/batch/transcript-editing) निर्देश शामिल था, तो `transcription` ऑब्जेक्ट में एडिट किए गए टेक्स्ट वाला `edited_transcript` फ़ील्ड भी होगा।

## अपना वेबहुक एंडपॉइंट लागू करना

इनकमिंग नोटिफ़िकेशन संभालने के लिए वेबहुक एंडपॉइंट लागू करने का एक उदाहरण यहां दिया गया है:

```javascript
import { ElevenLabsClient } from '@elevenlabs/elevenlabs-js';
import 'dotenv/config';
import express from 'express';

const elevenlabs = new ElevenLabsClient();

const app = express();
app.use(express.json());

const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET;

app.post('/webhook/speech-to-text', (req, res) => {
  try {
    const signature = req.headers['elevenlabs-signature'];
    const payload = JSON.stringify(req.body);
    let event;

    try {
      // Verify the webhook signature.
      event = await elevenlabs.webhooks.constructEvent(payload, signature, WEBHOOK_SECRET);
    } catch (error) {
      return res.status(401).json({ error: 'Invalid signature' });
    }

    if (event.type === 'speech_to_text.completed') {
      const { requestId, status, text, language_code } = event.data;

      console.log(`Transcription ${requestId} completed`);
      console.log(`Language: ${language_code}`);
      console.log(`Text: ${text}`);

      processTranscription(requestId, text, language_code);
    } else if (status === 'failed') {
      console.error(`Transcription ${requestId} failed`);
      handleTranscriptionError(requestId);
    }

    res.status(200).json({ received: true });
  } catch (error) {
    console.error('Webhook error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

async function processTranscription(requestId, text, language) {
  console.log('Processing completed transcription...');
}

async function handleTranscriptionError(requestId) {
  console.log('Handling transcription error...');
}

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});
```

## सुरक्षा से जुड़ी बातें

### सिग्नेचर वेरिफ़िकेशन

यह सुनिश्चित करने के लिए कि रिक्वेस्ट ElevenLabs से आई हैं, वेबहुक सिग्नेचर हमेशा वेरिफ़ाई करें।

### HTTPS की ज़रूरत

ट्रांसक्रिप्शन डेटा का सुरक्षित ट्रांसमिशन सुनिश्चित करने के लिए वेबहुक URLs में HTTPS होना ज़रूरी है।

### रेट लिमिटिंग

दुरुपयोग रोकने के लिए अपने वेबहुक एंडपॉइंट पर रेट लिमिटिंग लागू करें:

```javascript
import rateLimit from "express-rate-limit";

const webhookLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limit each IP to 100 requests per windowMs
  message: "Too many webhook requests from this IP",
});

app.use("/webhook", webhookLimiter);
```

### फ़ेलियर रिस्पॉन्स

उपयुक्त HTTP स्टेटस कोड लौटाएं:

* `200-299`: सफलता - वेबहुक सफलतापूर्वक प्रोसेस हुआ
* `400-499`: क्लाइंट एरर - वेबहुक को फिर से नहीं आजमाया जाएगा
* `500-599`: सर्वर एरर - वेबहुक को फिर से आजमाया जाएगा

## वेबहुक्स की टेस्टिंग

### लोकल डेवलपमेंट

लोकल टेस्टिंग के लिए, अपने लोकल सर्वर को एक्सपोज़ करने हेतु [ngrok](https://ngrok.com/) जैसे टूल इस्तेमाल करें:

```bash
ngrok http 3000
```

डेवलपमेंट के दौरान दिए गए HTTPS URL को अपने वेबहुक एंडपॉइंट के रूप में इस्तेमाल करें।

### वेबहुक टेस्टिंग

आप ट्रांसक्रिप्शन रिक्वेस्ट करके और अपने एंडपॉइंट को मॉनिटर करके अपने वेबहुक इम्प्लीमेंटेशन की टेस्टिंग कर सकते हैं:

```javascript
async function testWebhook() {
  const audioFile = new File([audioBuffer], "test.mp3", { type: "audio/mp3" });

  const result = await elevenlabs.speechToText.convert({
    file: audioFile,
    modelId: "scribe_v2",
    webhook: true,
  });

  console.log("Test transcription started:", result.requestId);
}
```

## अगले चरण

#### [सर्वर-साइड स्ट्रीमिंग](/docs/hi/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming)

WebSocket-आधारित स्ट्रीमिंग API का इस्तेमाल करके रियल टाइम में ऑडियो ट्रांसक्राइब करें।

#### [API रेफरेंस](/docs/hi/api-reference/speech-to-text)

पूरा स्पीच टू टेक्स्ट API रेफरेंस और पैरामीटर्स।