स्पीच टू टेक्स्ट API इंटीग्रेशन: डेवलपर गाइड

स्पीच टू टेक्स्ट API डेवलपर्स को अपनी ऐप्स में सीधे स्पीच रिकग्निशन और ट्रांसक्रिप्शन की सुविधा जोड़ने देता है। लेकिन STT API कनेक्ट करने से पहले, आपको कुछ आर्किटेक्चरल फैसले लेने होंगे।

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

इस गाइड में आपको ElevenLabs स्पीच टू टेक्स्ट API इंटीग्रेशन के लिए सब कुछ मिलेगा, साथ में क्लियर कोड उदाहरण जो आप सीधे प्रोडक्शन में इस्तेमाल कर सकते हैं। रेफरेंस के लिए ElevenLabs का स्पीच टू टेक्स्ट क्विकस्टार्ट और API गाइड एक अलग विंडो में खोल लें।

सारांश

• ElevenLabs स्पीच टू टेक्स्ट के दो मोड हैं: बैच (रिकॉर्डेड ऑडियो के लिए) और रियलटाइम (WebSocket के ज़रिए लाइव ऑडियो स्ट्रीम के लिए)।
• Scribe v2 बैच ट्रांसक्रिप्शन को 90+ भाषाओं में स्पीकर डायराइजेशन, कीटर्म प्रॉम्प्टिंग, एंटिटी डिटेक्शन, वर्ड-लेवल टाइमस्टैम्प और मल्टीचैनल सपोर्ट के साथ हैंडल करता है।
• Scribe v2 रियलटाइम लाइव स्ट्रीमिंग को ~150ms लेटेंसी के साथ हैंडल करता है, जैसे-जैसे आप बोलते हैं, पार्टियल ट्रांसक्रिप्ट देता है और स्पीच सेगमेंट पूरा होने पर फाइनल ट्रांसक्रिप्ट देता है।
• 8 मिनट से बड़ी फाइल्स के लिए, Scribe v2 खुद ही फाइल को हिस्सों में बांटकर साथ में ट्रांसक्राइब करता है। लंबे जॉब्स के लिए, सिंक्रोनस रिस्पॉन्स का इंतजार करने की बजाय वेबहुक्स का इस्तेमाल करें।
• कीटर्म प्रॉम्प्टिंग मॉडल को खास शब्दों की ओर बायस करती है - प्रोडक्ट नाम, टेक्निकल टर्म्स या अनोखे प्रॉपर नाउन के लिए यह कीवर्ड लिस्ट से ज्यादा भरोसेमंद है।

स्पीच टू टेक्स्ट API इंटीग्रेशन: बैच बनाम रियलटाइम

हर ElevenLabs STT API इंटीग्रेशन की शुरुआत एक आर्किटेक्चरल चॉइस से होती है: बैच या रियलटाइम। दोनों ही आपके डेवलपर एनवायरनमेंट में पावरफुल STT मॉडल लाते हैं, लेकिन आपकी चॉइस से फीचर्स और लेटेंसी पर असर पड़ता है।

यहाँ दोनों मोड्स की तुलना है:

• बैच (Scribe v2): एक पूरी ऑडियो या वीडियो फाइल लेता है, उसे ट्रांसक्राइब करता है और एक ही रिस्पॉन्स में पूरा ट्रांसक्रिप्ट देता है। इसमें सबसे ज्यादा फीचर्स मिलते हैं: 1,000 तक कीटर्म्स, डायराइजेशन के लिए 32 तक स्पीकर्स, एंटिटी डिटेक्शन, मल्टीचैनल मोड और असिंक डिलीवरी के लिए वेबहुक्स। स्टैंडर्ड मोड में 3 GB और 10 घंटे तक की फाइल्स सपोर्टेड हैं।
• रियलटाइम (Scribe v2 रियलटाइम): WebSocket के ज़रिए लाइव ऑडियो स्ट्रीम लेता है और जैसे-जैसे ऑडियो आता है, पार्टियल और फाइनल ट्रांसक्रिप्ट देता है, लगभग 150ms लेटेंसी के साथ। इसमें 50 तक कीटर्म्स और वर्ड-लेवल टाइमस्टैम्प सपोर्टेड हैं, और यह वॉइस असिस्टेंट्स, लाइव कैप्शनिंग या किसी भी ऐसी ऐप के लिए सही है जहाँ यूज़र बोल रहा हो और तुरंत रिस्पॉन्स चाहिए।

आइए इन दोनों के फर्क को और आसान भाषा में समझते हैं।

सिंपल रूल: जब ऑडियो पूरा हो चुका हो, तब बैच यूज़ करें; जब ऑडियो बनते समय ही ट्रांसक्राइब करना हो, तब रियलटाइम यूज़ करें।

Scribe v2 और Scribe v2 रियलटाइम कब चुनें

बैच और रियलटाइम अलग-अलग कामों के लिए बने हैं, गलत चॉइस करने पर बाद में दोबारा काम करना पड़ सकता है।

और समझने के लिए, यहाँ बताया गया है कि आप अपने यूज़ केस के हिसाब से मॉडल कैसे चुन सकते हैं:

• Scribe v2 तब सही है जब ऑडियो प्रोसेसिंग से पहले पूरा हो चुका हो, जैसे मीटिंग रिकॉर्डिंग, पॉडकास्ट ट्रांसक्रिप्शन, मीडिया फाइल्स या कोई भी ऑफलाइन प्रोसेसिंग। इसमें डायराइजेशन, एंटिटी डिटेक्शन और 1,000 तक कीटर्म्स जैसे सभी फीचर्स मिलते हैं।
• Scribe v2 रियलटाइम लाइव ऑडियो के लिए बना है। यह WebSocket स्ट्रीम लेता है और जैसे-जैसे ऑडियो आता है, ट्रांसक्रिप्ट देता है। वॉइस असिस्टेंट्स या ऐसे किसी भी सीनारियो के लिए सही है जहाँ यूज़र बोल रहा हो और आपकी ऐप को जवाब देना हो।

एक और बात ध्यान रखने वाली है कि एक्युरेसी भाषा के हिसाब से बदलती है। किसी भाषा को चुनने से पहले ट्रांसक्रिप्शन वर्ड एरर रेट देखना अच्छा रहेगा। Scribe v2 सभी 90+ सपोर्टेड भाषाओं के लिए वर्ड एरर रेट (WER) टियर पब्लिश करता है।

बहुत अच्छी एक्युरेसी (≤5% WER) में प्रमुख यूरोपीय भाषाएँ, जापानी, इंडोनेशियन, वियतनामी आदि शामिल हैं। हाई एक्युरेसी (5-10% WER) में हिंदी, बंगाली, मंदारिन, कोरियन, जॉर्जियन आदि शामिल हैं। पूरी डिटेल के लिए भाषा सपोर्ट डाक्यूमेंटेशन देखें।

ElevenLabs स्पीच टू टेक्स्ट API सेटअप करना

वर्किंग क्लाइंट बनाने के लिए सिर्फ दो आसान स्टेप्स चाहिए। पहले SDK इंस्टॉल करें। फिर अपनी क्रेडेंशियल्स को सुरक्षित तरीके से स्टोर करें।

पहला ट्रांसक्रिप्शन रिक्वेस्ट लिखने से पहले ये दोनों स्टेप्स करें।

SDK इंस्टॉल करें और अपनी API key को .env फाइल या अपने प्लेटफॉर्म के सीक्रेट्स मैनेजर में सुरक्षित रखें। कभी भी अपनी API key को ऐप में हार्डकोड न करें।

Python

pip install elevenlabs
pip install python-dotenv

TypeScript

npm install @elevenlabs/elevenlabs-js

.env फाइल बनाएं:

ELEVENLABS_API_KEY=<your_api_key_here>

क्लाइंट इनिशियलाइज़ करें:

Python

import os
from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

load_dotenv()

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

TypeScript

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

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

ElevenLabs STT API के साथ अपनी पहली बैच ट्रांसक्रिप्शन

अब जब आपने क्लाइंट इनिशियलाइज़ कर लिया है, तो आप अपनी पहली फाइल भेजने के लिए तैयार हैं।

बैच API एक फाइल लेता है, उसे ट्रांसक्राइब करता है और पूरा रिजल्ट सिंक्रोनसली देता है। नीचे का उदाहरण एक रिमोट ऑडियो फाइल को स्पीकर डायराइजेशन और ऑडियो इवेंट टैगिंग के साथ ट्रांसक्राइब करता है।

Python

# example.py
import os
from dotenv import load_dotenv
from io import BytesIO
import requests
from elevenlabs.client import ElevenLabs

load_dotenv()

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

audio_url = (
    "https://storage.googleapis.com/eleven-public-cdn/audio/marketing/nicole.mp3"
)
response = requests.get(audio_url)
audio_data = BytesIO(response.content)

transcription = elevenlabs.speech_to_text.convert(
    file=audio_data,
    model_id="scribe_v2",          # Model to use
    tag_audio_events=True,          # Tag audio events like laughter, applause, etc.
    language_code="eng",            # Language of the audio file. If set to None, the model will detect the language automatically.
    diarize=True,                   # Whether to annotate who is speaking
)

print(transcription)

इसे चलाएं:

python example.py

रिस्पॉन्स ऑब्जेक्ट में पूरा ट्रांसक्रिप्ट टेक्स्ट, वर्ड-लेवल एंट्रीज़ (टाइमस्टैम्प और स्पीकर IDs के साथ) और डिटेक्टेड ऑडियो इवेंट्स शामिल होते हैं।

हर वर्ड एंट्री में एक टाइप फील्ड होता है, जिसमें तीन में से कोई एक वैल्यू होती है:

• शब्द: ऑडियो में ट्रांसक्राइब किए गए शब्द।
• स्पेसिंग: उन भाषाओं में शब्दों के बीच के स्पेस। यह टाइप कई भाषाओं (जैसे जापानी, कैंटोनीज़, बर्मी) में लागू नहीं होता।
• ऑडियो_इवेंट: कोई भी नॉन-स्पीच साउंड (जैसे हँसी या खाँसी) के लिए टैग।

रिस्पॉन्स स्ट्रक्चर कुछ ऐसा दिखता है:

{
  "language_code": "en",
  "language_probability": 1,
  "text": "With a soft and whispery American accent, I'm the ideal choice for creating ASMR content, meditative guides, or adding an intimate feel to your narrative projects.",
  "words": [
    {
      "text": "With",
      "start": 0.119,
      "end": 0.259,
      "type": "word",
      "speaker_id": "speaker_0"
    },
    {
      "text": " ",
      "start": 0.239,
      "end": 0.299,
      "type": "spacing",
      "speaker_id": "speaker_0"
    },
    {
      "text": "a",
      "start": 0.279,
      "end": 0.359,
      "type": "word",
      "speaker_id": "speaker_0"
    }
  ]
}

language_probability फील्ड बताता है कि मॉडल को अपनी भाषा डिटेक्शन पर कितना भरोसा है, 0.00 से 1.00 के स्केल पर।

STT API रियलटाइम इंटीग्रेशन

रियलटाइम STT API इंटीग्रेशन थोड़ा अलग पैटर्न फॉलो करता है। एक रिक्वेस्ट और एक रिस्पॉन्स की बजाय, आप WebSocket कनेक्शन खोलेंगे और ट्रांसक्रिप्ट्स को जैसे ही वे आएं, पढ़ेंगे।

रियलटाइम API WebSocket के ज़रिए लाइव ऑडियो स्ट्रीम लेता है और जैसे ही ऑडियो आता है, ट्रांसक्रिप्ट देता है। इसमें दो तरह के ट्रांसक्रिप्ट मिलते हैं:

• पार्टियल ट्रांसक्रिप्ट: इंटरिम रिजल्ट्स जो मॉडल के ऑडियो प्रोसेस करते समय अपडेट होते हैं। ये बदल सकते हैं।
• कमिटेड ट्रांसक्रिप्ट: किसी पूरे स्पीच सेगमेंट के लिए फाइनल रिजल्ट। ये नहीं बदलेंगे। अगर आपने "include timestamps" ऑप्शन true किया है तो इनमें वर्ड-लेवल टाइमस्टैम्प भी हो सकते हैं।

क्लाइंट-साइड इम्प्लीमेंटेशन में आपकी API key की बजाय सिंगल-यूज़ टोकन का इस्तेमाल होता है। यह एक टेम्पररी क्रेडेंशियल है जो 15 मिनट बाद एक्सपायर हो जाता है, और सर्वर-साइड जेनरेट होता है ताकि आपकी API key ब्राउज़र में कभी न जाए।

स्टेप 1: सिंगल-यूज़ टोकन जेनरेट करें (सर्वर साइड)

// Node.js server
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

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

app.get("/scribe-token", yourAuthMiddleware, async (req, res) => {
  const token = await elevenlabs.tokens.singleUse.create("realtime_scribe");

  res.json(token);
});

स्टेप 2: कनेक्ट करें और ट्रांसक्राइब करें (क्लाइंट साइड, React)

import { useScribe } from "@elevenlabs/react";

function MyComponent() {
  const scribe = useScribe({
    modelId: "scribe_v2_realtime",
    onPartialTranscript: (data) => {
      console.log("Partial:", data.text);
    },
    onCommittedTranscript: (data) => {
      console.log("Committed:", data.text);
    },
    onCommittedTranscriptWithTimestamps: (data) => {
      console.log("Committed with timestamps:", data.text);
      console.log("Timestamps:", data.words);
    },
  });

  const handleStart = async () => {
    // Fetch a single use token from the server
    const token = await fetchTokenFromServer();

    await scribe.connect({
      token,
      microphone: {
        echoCancellation: true,
        noiseSuppression: true,
      },
    });
  };

  return (
    <div>
      <button onClick={handleStart} disabled={scribe.isConnected}>
        Start Recording
      </button>
      <button onClick={scribe.disconnect} disabled={!scribe.isConnected}>
        Stop
      </button>

      {scribe.partialTranscript && <p>Live: {scribe.partialTranscript}</p>}

      <div>
        {scribe.committedTranscripts.map((t) => (
          <p key={t.id}>{t.text}</p>
        ))}
      </div>
    </div>
  );
}

useScribe हुक WebSocket कनेक्शन लाइफसाइकल, माइक्रोफोन एक्सेस और ट्रांसक्रिप्ट स्टेट को मैनेज करता है। partialTranscript में मौजूदा इन-प्रोग्रेस टेक्स्ट रहता है; committedTranscripts में फाइनल सेगमेंट्स की लिस्ट बनती जाती है।

सर्वर-साइड स्ट्रीमिंग (माइक्रोफोन की बजाय URL या फाइल स्ट्रीम से ऑडियो ट्रांसक्राइब करने के लिए) के लिए देखें सर्वर-साइड स्ट्रीमिंग गाइड.

कॉनकरेंसी और लंबे फाइल्स को स्केल करना

लंबी फाइल्स के लिए ज्यादातर APIs से अलग स्केलिंग मॉडल चाहिए। इसे समझना जरूरी है।

बैच ट्रांसक्रिप्शन के लिए कॉनकरेंसी बाकी APIs से अलग काम करती है। कितनी रिक्वेस्ट्स एक साथ भेज सकते हैं, इसकी बजाय Scribe v2 लंबी फाइल्स को खुद ही इंटरनली पैरेललाइज करता है।

8 मिनट से बड़ी फाइल्स को हिस्सों में बांटकर साथ में ट्रांसक्राइब किया जाता है। कितने हिस्से एक साथ चलेंगे, यह ऐसे तय होता है:

Concurrency = min(4, round_up(audio_duration_secs / 480))

उदाहरण के लिए:

• 15 मिनट की फाइल में कॉनकरेंसी 2 होगी
• 120 मिनट की फाइल में कॉनकरेंसी 4 (मैक्सिमम) होगी

स्टैंडर्ड मोड में 10 घंटे और 3 GB तक की फाइल्स सपोर्टेड हैं। ध्यान दें: मल्टीचैनल मोड में ड्यूरेशन लिमिट कम है - नीचे मल्टीचैनल ट्रांसक्रिप्शन सेक्शन देखें।

सपोर्टेड फॉर्मैट्स की बात करें तो, STT API सबसे कॉमन ऑडियो और वीडियो फॉर्मैट्स लेता है:

• ऑडियो: AAC, AIFF, OGG, MP3, OPUS, WAV, FLAC, M4A, WebM.
• वीडियो: MP4, AVI, MKV, MOV, WMV, FLV, WebM, MPEG, 3GPP.

आप वीडियो फाइल सीधे भेज सकते हैं और उसकी ऑडियो ट्रैक का ट्रांसक्रिप्ट बिना किसी प्री-प्रोसेसिंग के पा सकते हैं।

कीटर्म प्रॉम्प्टिंग

जनरल मॉडल्स ब्रांड नाम और टेक्निकल टर्म्स को गलत ट्रांसक्राइब कर सकते हैं। कीटर्म प्रॉम्प्टिंग इसे ठीक करने के लिए है।

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

कीटर्म प्रॉम्प्टिंग की खासियत यह है कि यह कॉन्टेक्स्ट का इस्तेमाल करती है, जिससे यह सिंपल कीवर्ड लिस्ट से ज्यादा भरोसेमंद है। अगर आप "ElevenLabs" को कीटर्म के रूप में देते हैं, तो मॉडल कंपनी का नाम सही ट्रांसक्राइब करेगा। बिना इसके, मॉडल "I've worked at eleven labs for a year" को गलत भी ट्रांसक्राइब कर सकता है।

बिना कीटर्म प्रॉम्प्टिंग के:

I work at eleven labs.

कीटर्म्स=["ElevenLabs"] के साथ:

I work at ElevenLabs.

बैच में 1,000 तक कीटर्म्स (हर एक 50 कैरेक्टर तक) सपोर्टेड हैं। रियलटाइम में 50 तक कीटर्म्स (हर एक 20 कैरेक्टर तक) सपोर्टेड हैं।

कीटर्म्स के साथ बैच ट्रांसक्रिप्शन

Python

import os
from dotenv import load_dotenv
from io import BytesIO
import requests
from elevenlabs.client import ElevenLabs

load_dotenv()

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

audio_url = (
    "https://storage.googleapis.com/eleven-public-cdn/documentation_assets/audio/stt-keyterm-prompting.mp3"
)
response = requests.get(audio_url)
audio_data = BytesIO(response.content)

transcription = elevenlabs.speech_to_text.convert(
    file=audio_data,
    model_id="scribe_v2",
    # Keyterms to prompt the model with.
    # Up to 1,000 keyterms can be provided, with a maximum length of 50 characters each
    keyterms=["ElevenLabs"],
)

print(transcription)

कीटर्म्स के साथ रियलटाइम स्ट्रीमिंग

रियलटाइम WebSocket से कनेक्ट करते समय कीटर्म्स पास करें:

Python

connection = await elevenlabs.speech_to_text.realtime.connect(RealtimeUrlOptions(
    model_id="scribe_v2_realtime",
    keyterms=["ElevenLabs"],
))

या उन्हें सीधे WebSocket URL में क्वेरी पैरामीटर के रूप में पास करें:

wss://api.elevenlabs.io/v1/speech-to-text/realtime?model_id=scribe_v2_realtime&keyterms=ElevenLabs&keyterms=AnotherTerm

कीटर्म प्रॉम्प्टिंग का अतिरिक्त खर्च है। डिटेल्स के लिए देखें API प्राइसिंग पेज।

एडवांस्ड फीचर्स

ऊपर बताए गए स्टेप्स आपको कोर STT API ट्रांसक्रिप्शन फ्लो से गुजारते हैं, लेकिन कई ऐसे फीचर्स हैं जो फाइनल आउटपुट को और बेहतर बनाते हैं। यहाँ कुछ एडवांस्ड फीचर्स हैं जिन्हें आप अपनी स्पीच टू टेक्स्ट API में इस्तेमाल कर सकते हैं:

• स्पीकर डायराइजेशन जिससे पता चले कौन बोल रहा है
• नो-वर्बेटिम मोड जिससे ट्रांसक्रिप्शन साफ हो जाता है
• एंटिटी डिटेक्शन जिससे संवेदनशील डेटा को फ्लैग किया जा सके
• मल्टीचैनल ट्रांसक्रिप्शन जिससे ऑडियो चैनल्स अलग-अलग रहें

आइए इन्हें और विस्तार से समझते हैं।

स्पीकर डायराइजेशन

बैच रिक्वेस्ट में diarize=True करें ताकि पता चले कौन बोल रहा है। Scribe v2 में 32 तक स्पीकर्स सपोर्टेड हैं। रिस्पॉन्स में हर शब्द के साथ एक speaker_id फील्ड (जैसे speaker_0, speaker_1) आता है, जिससे आप ट्रांसक्रिप्ट को स्पीकर के हिसाब से अलग कर सकते हैं।

डायराइजेशन मीटिंग ट्रांसक्रिप्शन, इंटरव्यू प्रोसेसिंग या किसी भी मल्टी-स्पीकर रिकॉर्डिंग के लिए फायदेमंद है जहाँ सही स्पीकर को शब्द असाइन करना जरूरी हो।

नो-वर्बेटिम मोड

जब no_verbatim=True होता है, तो मॉडल ट्रांसक्रिप्ट से फिलर शब्द, फॉल्स स्टार्ट्स और डिस्फ्लुएंसीज़ हटा देता है। जैसे "Erm, M-maybe we should, uh, go with option A" बदलकर "Maybe we should go with option A." हो जाता है।

यह आउटपुट को सबटाइटल्स, समरी या किसी भी ऐसे यूज़ केस के लिए साफ बनाता है जहाँ पढ़ने में आसानी जरूरी हो। यह बैच (scribe_v2) और रियलटाइम (scribe_v2_realtime) दोनों में उपलब्ध है।

एंटिटी डिटेक्शन और रिडैक्शन

Scribe v2 ट्रांसक्रिप्ट में एंटिटीज़ को डिटेक्ट और लेबल कर सकता है, हर डिटेक्टेड एंटिटी के लिए एक्ज़ैक्ट टाइमस्टैम्प के साथ। कैटेगरीज में PII (नाम, क्रेडिट कार्ड नंबर, SSNs), PHI (मेडिकल कंडीशंस), और PCI (पेमेंट कार्ड जानकारी) आदि शामिल हैं। सभी सपोर्टेड एंटिटी टाइप्स की लिस्ट के लिए देखें एंटिटी डिटेक्शन डाक्यूमेंटेशन।

यह खासकर कंप्लायंस यूज़ केस के लिए फायदेमंद है, जिससे आप ट्रांसक्रिप्ट स्टोर या डिस्प्ले करने से पहले संवेदनशील जानकारी पहचानकर ऑटोमेटिकली रिडैक्ट कर सकते हैं।

एंटिटी डिटेक्शन का अतिरिक्त खर्च $0.070 (प्रति घंटा) बेस ट्रांसक्रिप्शन कॉस्ट पर है। डिटेल्स के लिए देखें API प्राइसिंग पेज।

मल्टीचैनल ट्रांसक्रिप्शन

जब use_multi_channel=True होता है, हर ऑडियो चैनल को अलग से ट्रांसक्राइब किया जाता है और उसके चैनल नंबर के हिसाब से स्पीकर ID दी जाती है। 5 चैनल्स तक सपोर्टेड हैं। मल्टीचैनल मोड में मैक्स फाइल ड्यूरेशन 1 घंटा है।

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

वेबहुक्स के साथ असिंक डिलीवरी

कम वॉल्यूम पर रिजल्ट के लिए पोलिंग ठीक है, लेकिन जैसे ही आप लंबी फाइल्स या हाई-थ्रूपुट पाइपलाइन पर काम करेंगे, यह स्केल नहीं करेगा। वेबहुक्स इस समस्या का हल हैं, क्योंकि रिजल्ट आपको पुश किया जाता है।

लंबी फाइल्स या हाई-वॉल्यूम ट्रांसक्रिप्शन पाइपलाइन के लिए, सिंक्रोनस रिस्पॉन्स का इंतजार हमेशा प्रैक्टिकल नहीं होता। वेबहुक्स से आप ट्रांसक्रिप्शन रिक्वेस्ट सबमिट कर सकते हैं और प्रोसेसिंग पूरी होने पर रिजल्ट अपने एंडपॉइंट पर पा सकते हैं, बिना पोलिंग के।

वेबहुक सेटअप करना

ElevenLabs डैशबोर्ड में जाएं डेवलपर्स > वेबहुक्स, क्लिक करें वेबहुक बनाएं, और सेटअप करें:

• नाम: अपने वेबहुक के लिए एक डिस्क्रिप्टिव और याद रखने वाला नाम लिखें।
• कॉलबैक URL: वेबहुक में एक पब्लिकली एक्सेसिबल HTTPS एंडपॉइंट जोड़ें।
• वेबहुक ऑथ मेथड: HMAC या OAuth में से चुनें (सुरक्षा के लिए ऑप्शनल लेकिन स्ट्रॉन्गली रिकमेंडेड)।
• इवेंट्स: ऑप्शंस में से Transcription completed चुनें।

वेबहुक डिलीवरी के साथ ट्रांसक्रिप्शन सबमिट करना

Python

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

जब webhook=True होता है, रिक्वेस्ट ट्रांसक्रिप्ट के बिना जल्दी रिटर्न हो जाती है। प्रोसेसिंग पूरी होने पर फाइनल ट्रांसक्रिप्ट आपके एंडपॉइंट पर POST रिक्वेस्ट के रूप में भेजा जाता है।

अपना वेबहुक एंडपॉइंट इम्प्लीमेंट करना

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

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

वेबहुक पेलोड स्ट्रक्चर

आपका एंडपॉइंट नीचे दिए गए फॉर्मेट में POST रिसीव करता है:

{
  "type": "speech_to_text_transcription",
  "data": {
    "request_id": "some-request-id-123",
    "webhook_metadata": {},
    "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"
        }
      ]
    }
  }
}

वेबहुक सुरक्षा के बेस्ट प्रैक्टिस

वेबहुक्स के साथ काम करते समय, कुछ सिक्योरिटी स्टेप्स हैं जिनसे आप सुनिश्चित कर सकते हैं कि इवेंट्स सही तरीके से डिलीवर और प्रोसेस हों।

• वेबहुक सिग्नेचर वेरिफाई करें: हमेशा elevenlabs.webhooks.constructEvent() से वेबहुक सिग्नेचर वेरिफाई करें ताकि वे ElevenLabs से ही आए हों।
• HTTPS एंडपॉइंट्स का इस्तेमाल करें: वेबहुक URLs में डेटा को छेड़छाड़ से बचाने के लिए HTTPS होना जरूरी है।
• सही HTTP स्टेटस कोड रिटर्न करें: सक्सेस के लिए 200-299, क्लाइंट एरर के लिए 400-499 (ये रीट्राई नहीं होंगे), और सर्वर एरर के लिए 500-599 (ये रीट्राई होंगे) रिटर्न करें।
• लोकल डेवेलपमेंट के लिए टनलिंग टूल का इस्तेमाल करें: लोकल डेवेलपमेंट के लिए, ngrok जैसे टूल से अपने लोकल सर्वर को पब्लिक HTTPS URL पर एक्सपोज़ करें।

इन स्ट्रैटेजीज़ के साथ, आप वेबहुक्स को भरोसे के साथ इस्तेमाल कर सकते हैं।

स्पीच टू टेक्स्ट API इंटीग्रेशन के लिए मुख्य बातें

प्रोडक्शन स्पीच टू टेक्स्ट API इंटीग्रेशन कुछ अहम फैसलों पर निर्भर करता है।

अगर ये सही चुन लिए तो बाकी सब आसान हो जाएगा:

• यूज़ केस के हिसाब से मोड चुनें: जब ऑडियो प्रोसेसिंग से पहले पूरा हो, तब बैच (scribe_v2) यूज़ करें। जब ऑडियो बनते समय ही ट्रांसक्राइब करना हो, जैसे एजेंट्स, वॉइस असिस्टेंट्स या लाइव कैप्शन के लिए, तब रियलटाइम (scribe_v2_realtime) यूज़ करें।
• स्पेसिफिक शब्दों की एक्युरेसी के लिए कीटर्म्स यूज़ करें: प्रोडक्ट नाम, टेक्निकल टर्म्स या अनोखे प्रॉपर नाउन को कीटर्म्स के रूप में पास करें। मॉडल इन्हें सही कॉन्टेक्स्ट में इस्तेमाल करता है, बिना ओवर-ट्रिगर किए।
• लंबी फाइल्स को API पर छोड़ दें: 8 मिनट से बड़ी फाइल्स खुद-ब-खुद पैरेललाइज हो जाती हैं, आपको खुद से हिस्से करने की जरूरत नहीं। स्टैंडर्ड मोड में 10 घंटे और 3 GB तक की फाइल्स सपोर्टेड हैं।
• असिंक पाइपलाइंस के लिए वेबहुक्स यूज़ करें: लंबे जॉब्स या हाई-वॉल्यूम प्रोसेसिंग के लिए, webhook=True से आप सबमिट करके आगे बढ़ सकते हैं। हर इनकमिंग वेबहुक पेलोड की सिग्नेचर वेरिफाई करें।
• साफ आउटपुट के लिए नो-वर्बेटिम मोड ऑन करें: अगर आपका यूज़ केस सबटाइटल्स, समरी या NLP प्रोसेसिंग है, तो no_verbatim=True से फिलर शब्द और डिस्फ्लुएंसीज़ अपने आप हट जाते हैं।
• अलग ऑडियो ट्रैक्स के लिए मल्टीचैनल मोड यूज़ करें: अगर आपकी रिकॉर्डिंग में हर स्पीकर के लिए अलग चैनल है (कॉल सेंटर रिकॉर्डिंग, इंटरव्यू सेटअप), तो मल्टीचैनल ट्रांसक्रिप्शन मिक्स्ड फाइल पर डायराइजेशन से ज्यादा एक्युरेट स्पीकर एट्रिब्यूशन देता है। इस मोड में 1 घंटे की ड्यूरेशन लिमिट है।

अगर आप और जानकारी चाहते हैं, तो फुल API रेफरेंस देखें।

ElevenAPI के साथ अपनी स्पीच टू टेक्स्ट इंटीग्रेशन बनाएं

इस गाइड को पढ़ने के बाद, आपके पास प्रोडक्शन स्पीच टू टेक्स्ट API इंटीग्रेशन के लिए हर पैटर्न है। बैच और रियलटाइम ट्रांसक्रिप्शन, एडवांस्ड फीचर्स जैसे कीटर्म प्रॉम्प्टिंग और असिंक डिलीवरी के साथ, आप अपनी ऐप को STT से जोड़ने के लिए तैयार हैं।

शुरुआत करें और और जानें स्पीच टू टेक्स्ट API के बारे में या साइन अप करें और ElevenAPI के साथ आज ही अपनी पहली कॉल करें।

STT API इंटीग्रेशन से जुड़े सवाल-जवाब