---
title: "ब्राउज़र ऑडियो रिकॉर्ड कर speech-to-text API को भेजें"
description: "MediaRecorder से माइक्रोफ़ोन रिकॉर्ड करें, WebM या Safari का MP4 16 kHz WAV में बदलें, और API key रखने वाले छोटे सर्वर से ट्रांसक्रिप्शन API को भेजें।"
url: https://broadrouter.com/hi/blog/record-browser-audio-transcription-api/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/record-browser-audio-transcription-api/) (2026-11-15 को अपडेट किया गया).

# ब्राउज़र में ऑडियो रिकॉर्ड करें और speech-to-text API को भेजें

BroadNet Inference टीम · 6 मिनट में पढ़ें · प्रकाशित 2026-11-15

getUserMedia और MediaRecorder से रिकॉर्ड करें, isTypeSupported से फ़ॉर्मैट चुनें और ख़ाली chunk हटा दें। अगर API सिर्फ़ WAV या MP3 लेता है, तो ब्राउज़र में डिकोड करके 16 kHz मोनो WAV बनाएँ, या सर्वर पर ffmpeg से बदलें। दोनों हालात में अपने बैकएंड से भेजें, ताकि API key ब्राउज़र तक कभी न पहुँचे।

## मुख्य बातें

-   ब्राउज़र कंप्रेस्ड फ़ॉर्मैट रिकॉर्ड करते हैं: Chrome Opus वाला WebM देता है, और WebKit Safari के लिए AAC वाला MP4 बताता है। OpenAI दोनों लेता है; जो API सिर्फ़ WAV या MP3 लेते हैं, जैसे BroadNet, उनके लिए कन्वर्ज़न का एक क़दम चाहिए।
-   getUserMedia सिर्फ़ secure context (HTTPS या localhost) में चलता है। बाक़ी जगह navigator.mediaDevices undefined होता है, इसलिए कॉल करने से पहले उसकी जाँच करें।
-   16 kHz मोनो 16-bit WAV प्रति सेकंड 32,000 बाइट है। BroadNet की 26,214,400 बाइट की सीमा में इसके लगभग 13 मिनट 39 सेकंड आते हैं; इससे लंबा कुछ भी हो तो बाँट दें।
-   decodeAudioData को पूरी फ़ाइल चाहिए और वह अपने context की रेट पर resample करता है, इसलिए 16,000 Hz वाला OfflineAudioContext resampling आपके लिए कर देता है।
-   पेज से ट्रांसक्रिप्शन API को कभी कॉल न करें। ऑडियो अपने सर्वर पर भेजें, वहाँ उसका साइज़ और टाइप जाँचें, और key सर्वर में जोड़ें।

**इस पेज पर**

1.  ब्राउज़र किस फ़ॉर्मैट में रिकॉर्ड करता है?
2.  माइक्रोफ़ोन से रिकॉर्ड कैसे करें?
3.  ब्राउज़र में रिकॉर्डिंग को WAV में कैसे बदलें?
4.  इसकी जगह सर्वर पर कैसे बदलें?
5.  API key को ब्राउज़र से बाहर कैसे रखें?
6.  हमने इसे कैसे टेस्ट किया?
7.  इसकी लागत कितनी है?
8.  BroadNet Inference कहाँ फ़िट होता है

वेब ऐप में वॉइस मैसेज रिकॉर्ड करने के लिए लगभग तीस लाइन JavaScript काफ़ी है। दिक़्क़तें फ़ाइल भेजते समय शुरू होती हैं: ब्राउज़र ने WebM या MP4 रिकॉर्ड किया, API कुछ और चाहता है, iPhone ख़ामोश क्लिप पर “Thank you” लौटाता है, और जो ट्यूटोरियल आपने कॉपी किया वह API key पेज में ही रख देता है। यह पोस्ट पूरा रास्ता बनाती है और हर हिस्से को टेस्ट करती है: रिकॉर्ड करें, WAV में बदलें, साइज़ जाँचें और एक छोटे सर्वर के ज़रिए आगे भेजें।

उदाहरण ऐसे API के लिए हैं जो सिर्फ़ WAV या MP3 लेता है। BroadNet Inference ऐसा ही है: उसके डॉक्स हर फ़ाइल के लिए 26,214,400 बाइट तक WAV (`audio/wav`) या MP3 (`audio/mpeg`) लिस्ट करते हैं। अगर आपका API WebM लेता है, तो कन्वर्ज़न छोड़ दें और बाक़ी रखें। OpenAI की speech-to-text गाइड 25 MB तक flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav और webm लिस्ट करती है।

## ब्राउज़र किस फ़ॉर्मैट में रिकॉर्ड करता है?

`MediaRecorder` ब्राउज़र का चुना हुआ कंप्रेस्ड फ़ॉर्मैट रिकॉर्ड करता है, जब तक आप कोई ऐसा फ़ॉर्मैट न माँगें जिसे वह सपोर्ट करता हो। `MediaRecorder.isTypeSupported()` से पूछें और पहला मैच लें:

| टाइप स्ट्रिंग | आम तौर पर ब्राउज़र |
| --- | --- |
| `audio/webm;codecs=opus` | Chrome, Edge, Firefox |
| `audio/mp4` | Safari ([WebKit AAC वाला MP4 बताता है](https://webkit.org/blog/11353/mediarecorder-api/)); हमारे टेस्ट में Chromium ने भी इसे सपोर्टेड बताया |
| `audio/ogg;codecs=opus` | Firefox |

2026-11-15 को headless Chromium में `isTypeSupported` ने WebM/Opus और MP4 के लिए true और Ogg/Opus के लिए false लौटाया। इस टेबल को शुरुआती बिंदु मानें, वादा नहीं। MDN बताता है कि `true` का मतलब है कि ब्राउज़र सिद्धांत रूप में उस टाइप को रिकॉर्ड कर सकता है; संसाधन कम पड़ें तो रिकॉर्डिंग फिर भी फ़ेल हो सकती है। recorder बनाने के बाद हमेशा `recorder.mimeType` पढ़ें, और अपलोड पर वही लेबल लगाएँ, वह नहीं जो आपने माँगा था।

## माइक्रोफ़ोन से रिकॉर्ड कैसे करें?

ब्राउज़र के दो नियम कोड का रूप तय करते हैं। पहला, `getUserMedia` सिर्फ़ [secure context](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia) में मौजूद होता है: HTTPS, `localhost` या `file:` URL। किसी दूसरे होस्ट से सादे HTTP पर `navigator.mediaDevices` `undefined` होता है, इसलिए उसे कॉल करने पर अनुमति माँगने की जगह `TypeError` आता है। दूसरा, यूज़र को अनुमति देनी होती है, और मना करने पर `NotAllowedError` आता है। दोनों को ऐसे मैसेज के साथ संभालें जिस पर यूज़र कुछ कर सके।

```js
// record.js: record from the microphone, return a 16 kHz mono WAV Blob.
const TYPES = ["audio/webm;codecs=opus", "audio/mp4", "audio/ogg;codecs=opus"];

export async function startRecording() {
  if (!navigator.mediaDevices?.getUserMedia) {
    throw new Error("Microphone access needs HTTPS (or localhost).");
  }
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  const mimeType = TYPES.find((t) => MediaRecorder.isTypeSupported(t));
  const rec = new MediaRecorder(stream, mimeType ? { mimeType } : {});
  const chunks = [];
  rec.ondataavailable = (e) => { if (e.data.size > 0) chunks.push(e.data); };
  rec.start(1000); // a chunk every second, so a crash loses at most one second
  return () => new Promise((resolve) => {
    rec.onstop = () => {
      stream.getTracks().forEach((t) => t.stop()); // turn the mic indicator off
      resolve(new Blob(chunks, { type: rec.mimeType }));
    };
    rec.stop();
  });
}
```

इसकी तीन बातें असली बग रिपोर्ट से आई हैं:

-   **ख़ाली chunk हटा दें।** iPhone पर MediaRecorder के बारे में OpenAI फ़ोरम के एक थ्रेड में, एक डेवलपर ने पाया कि iOS पर `dataavailable` ख़ाली डेटा के साथ फ़ायर हो रहा था, और उन chunk को हटाने से समस्या ठीक हुई। एक और डेवलपर ने यही लक्षण timeslice, `start(1000)`, के साथ शुरू करके ठीक किया।
-   **ट्रैक बंद करें।** recorder रोकने से माइक्रोफ़ोन छूटता नहीं। `getTracks().forEach(t => t.stop())` के बिना ब्राउज़र रिकॉर्डिंग इंडिकेटर दिखाता रहता है।
-   **chunk गिनकर रिकॉर्डिंग का समय न नापें।** MDN चेतावनी देता है कि timeslice के अंतराल सटीक नहीं होते, और जब Safari माइक्रोफ़ोन रोकता है या Android Chrome स्क्रीन लॉक करता है तो ये लंबे हो सकते हैं। अगर आप अवधि दिखाते हैं या कोई सीमा लागू करते हैं, तो अपना टाइमर रखें।

## ब्राउज़र में रिकॉर्डिंग को WAV में कैसे बदलें?

Web Audio API वह सब डिकोड कर सकता है जो ब्राउज़र ने रिकॉर्ड किया। MDN की दो बातें इसे छोटा बना देती हैं: `decodeAudioData` सिर्फ़ पूरी फ़ाइल पर चलता है, टुकड़ों पर नहीं, इसलिए `stop()` के बाद डिकोड करें; और वह डिकोड किए गए ऑडियो को अपने context की sample rate पर resample करता है। इसलिए 16,000 Hz पर बना `OfflineAudioContext` बिना किसी अतिरिक्त resampling कोड के 16 kHz सैंपल लौटा देता है। इसका constructor 3,000 से 768,000 Hz तक कोई भी रेट लेता है।

```js
export async function toWav16k(blob) {
  // decodeAudioData needs the whole file and resamples to the context's rate.
  const ctx = new OfflineAudioContext(1, 1, 16000);
  const audio = await ctx.decodeAudioData(await blob.arrayBuffer());
  return encodeWav(mixDown(audio), 16000);
}

export function mixDown(audio) {
  const out = new Float32Array(audio.length);
  for (let c = 0; c < audio.numberOfChannels; c++) {
    const ch = audio.getChannelData(c);
    for (let i = 0; i < out.length; i++) out[i] += ch[i] / audio.numberOfChannels;
  }
  return out;
}

export function encodeWav(samples, rate) {
  const buf = new ArrayBuffer(44 + samples.length * 2);
  const v = new DataView(buf);
  const str = (o, s) => [...s].forEach((ch, i) => v.setUint8(o + i, ch.charCodeAt(0)));
  str(0, "RIFF"); v.setUint32(4, 36 + samples.length * 2, true); str(8, "WAVE");
  str(12, "fmt "); v.setUint32(16, 16, true); v.setUint16(20, 1, true); // PCM
  v.setUint16(22, 1, true); v.setUint32(24, rate, true);                // mono
  v.setUint32(28, rate * 2, true); v.setUint16(32, 2, true); v.setUint16(34, 16, true);
  str(36, "data"); v.setUint32(40, samples.length * 2, true);
  for (let i = 0; i < samples.length; i++) {
    const s = Math.max(-1, Math.min(1, samples[i]));
    v.setInt16(44 + i * 2, s < 0 ? s * 0x8000 : s * 0x7fff, true);
  }
  return new Blob([buf], { type: "audio/wav" });
}
```

16 kHz मोनो क्यों: BroadNet का अपना ffmpeg उदाहरण यही सेटिंग इस्तेमाल करता है (`-ar 16000 -ac 1`), यह बोली की फ़्रीक्वेंसी रेंज बनाए रखता है, और 48 kHz के मुक़ाबले एक-तिहाई बाइट लेता है। स्टीरियो एक आवाज़ के लिए बिना किसी फ़ायदे के साइज़ दोगुना कर देता है। फ़ायदे-नुक़सान के लिए [sample rate](https://broadrouter.com/hi/glossary/sample-rate/) देखें।

साइज़ का हिसाब मायने रखता है, क्योंकि WAV कंप्रेस्ड नहीं होता। प्रति सेकंड 16,000 सैंपल, हर एक 2 बाइट, यानी प्रति सेकंड 32,000 बाइट। 44 बाइट के हेडर के साथ BroadNet की 26,214,400 बाइट की सीमा में 819 सेकंड आते हैं: लगभग 13 मिनट 39 सेकंड। इससे लंबी किसी भी चीज़ के लिए रिकॉर्डिंग को एक सीमा पर रोकें, या सर्वर पर बाँटें, जैसा [लंबी ऑडियो फ़ाइलें ट्रांसक्राइब करना](https://broadrouter.com/hi/blog/transcribe-long-audio-files-api/) में बताया गया है। [ऑडियो स्प्लिटर](https://broadrouter.com/tools/audio-splitter-ffmpeg/) ffmpeg कमांड लिख देता है।

ब्राउज़र में कन्वर्ज़न यूज़र का CPU और मेमोरी ख़र्च करता है, और पूरी डिकोड की हुई क्लिप 32-bit float के रूप में मेमोरी में रहती है। कुछ मिनट के वॉइस मैसेज के लिए यह ठीक है। लंबी रिकॉर्डिंग के लिए कंप्रेस्ड फ़ाइल अपलोड करें और सर्वर पर बदलें।

## इसकी जगह सर्वर पर कैसे बदलें?

कंप्रेस्ड रिकॉर्डिंग जैसी है वैसी भेजें और काम ffmpeg को करने दें। पेज में कम कोड, छोटा अपलोड, और नतीजा वही:

```bash
ffmpeg -i in.webm -ar 16000 -ac 1 out.wav
```

अपलोड को ffmpeg में पाइप करने की जगह एक अस्थायी फ़ाइल में लिखें। MP4 फ़ाइलें अपना इंडेक्स आख़िर में रख सकती हैं, और ffmpeg उन्हें पाइप से हमेशा नहीं पढ़ पाता। [WhatsApp वॉइस नोट गाइड](https://broadrouter.com/hi/guides/transcribe-whatsapp-voice-notes/) `.ogg` फ़ाइलों के लिए यही कमांड इस्तेमाल करती है।

## API key को ब्राउज़र से बाहर कैसे रखें?

पेज और API के बीच एक छोटा एंडपॉइंट रखें। वह रिकॉर्डिंग लेता है, ज़रूरत हो तो बदलता है, साइज़ जाँचता है, environment variable से key जोड़ता है और आगे भेजता है। Node 18 और उसके बाद के वर्शन में `fetch`, `FormData` और `Blob` पहले से मौजूद हैं, इसलिए इसके लिए कोई पैकेज नहीं चाहिए:

```js
// server.mjs: POST /transcribe with the recording as the body. The key stays here.
import http from "node:http";
import { execFile } from "node:child_process";
import { mkdtemp, writeFile, readFile, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { promisify } from "node:util";

const API = process.env.BROADNET_BASE_URL ?? "https://inference.broadnet.ai/v1";
const KEY = process.env.BROADNET_API_KEY;
const FFMPEG = process.env.FFMPEG ?? "ffmpeg";
const MAX = 26_214_400; // BroadNet's per-file cap in bytes
const run = promisify(execFile);

async function readBody(req, limit) {
  const parts = []; let n = 0;
  for await (const c of req) { n += c.length; if (n > limit) throw Object.assign(new Error("too large"), { code: 413 }); parts.push(c); }
  return Buffer.concat(parts);
}

async function toWav(bytes) {
  // Temp files, not pipes: an MP4 from Safari can keep its index at the end.
  const dir = await mkdtemp(join(tmpdir(), "rec-"));
  try {
    await writeFile(join(dir, "in"), bytes);
    await run(FFMPEG, ["-v", "error", "-i", join(dir, "in"), "-ar", "16000", "-ac", "1", join(dir, "out.wav")]);
    return await readFile(join(dir, "out.wav"));
  } finally { await rm(dir, { recursive: true, force: true }); }
}

http.createServer(async (req, res) => {
  const reply = (code, obj) => { res.writeHead(code, { "content-type": "application/json" }); res.end(JSON.stringify(obj)); };
  if (req.method !== "POST" || req.url !== "/transcribe") return reply(404, { error: "not found" });
  try {
    const type = (req.headers["content-type"] ?? "").split(";")[0];
    let body = await readBody(req, 4 * MAX);
    if (type !== "audio/wav" && type !== "audio/mpeg") {
      try { body = await toWav(body); }
      catch { return reply(400, { error: "Could not read the recording." }); }
    }
    if (body.length > MAX) return reply(413, { error: "Recording too long; split it first." });
    const form = new FormData();
    form.append("model", "broadnet/cohere-transcribe-arabic");
    form.append("language", "ar");
    form.append("file", new Blob([body], { type: type === "audio/mpeg" ? "audio/mpeg" : "audio/wav" }),
      type === "audio/mpeg" ? "audio.mp3" : "audio.wav");
    const r = await fetch(`${API}/audio/transcriptions`, {
      method: "POST", headers: { Authorization: `Bearer ${KEY}` }, body: form,
    });
    const data = await r.json();
    return r.ok ? reply(200, { text: data.text }) : reply(r.status, { error: data });
  } catch (e) {
    return reply(e.code === 413 ? 413 : 500, { error: String(e.message ?? e) });
  }
}).listen(process.env.PORT ?? 8787);
```

फिर पेज या तो WAV भेजता है या कच्ची रिकॉर्डिंग:

```js
const stop = await startRecording();
// ...later, when the user taps Stop:
const raw = await stop();
const wav = await toWav16k(raw);          // or send `raw` and let the server convert
const r = await fetch("/transcribe", { method: "POST", headers: { "content-type": wav.type }, body: wav });
const { text } = await r.json();
```

इसे अपने हिसाब से ढालते समय ये बातें बनाए रखें:

-   **`language` हमेशा भेजें।** BroadNet के डॉक्स कहते हैं कि वरना अरबी लैटिन अक्षरों में transliterate होकर लौट सकती है। अरबी मॉडल के साथ `ar` इस्तेमाल करें, या `broadnet/cohere-transcribe` पर जाएँ और उसकी 14 भाषाओं में से सही कोड दें।
-   **सामान्य एरर लौटाएँ।** हमारे टेस्ट प्रॉक्सी का पहला वर्शन ffmpeg का एरर वापस भेज देता था, जिसमें सर्वर का एक फ़ाइल पाथ था। ऊपर वाला कोड इसकी जगह “Could not read the recording.” लौटाता है।
-   **डिप्लॉय करने से पहले ऑथेंटिकेशन और rate limit जोड़ें।** वरना जिसे भी `/transcribe` मिल जाए, वह आपका बैलेंस ख़र्च करेगा। बाक़ी बातें [LLM API key सुरक्षा](https://broadrouter.com/hi/blog/llm-api-key-security/) में हैं, और BroadNet की keys को [IP allow-list](https://broadrouter.com/hi/guides/api-keys-ip-allow-lists/) से सीमित किया जा सकता है।
-   **लगभग ख़ामोश क्लिप अस्वीकार करें।** फ़ोरम पर गढ़े हुए “Thank you” या “Bye” ट्रांसक्रिप्ट की रिपोर्टें ख़ामोश या टूटी रिकॉर्डिंग से जुड़ी हैं। भुगतान करने से पहले अवधि (WAV बाइट ÷ 32,000) और, हो सके तो, सिग्नल लेवल जाँचें।

## हमने इसे कैसे टेस्ट किया?

कोई BroadNet key इस्तेमाल नहीं हुई। 2026-11-15 को हमने ऊपर वाला कोड `/v1/audio/transcriptions` के एक लोकल mock पर चलाया:

1.  **Node में encoder।** दो clipped सैंपल वाली 440 Hz टोन के एक सेकंड पर `encodeWav` ने 32,044 बाइट बनाए। Python के `wave` मॉड्यूल ने इसे 1 चैनल, 16,000 Hz, 2 बाइट के सैंपल, 16,000 फ़्रेम के रूप में पढ़ा, और ffmpeg ने `pcm_s16le, 16000 Hz, mono` के रूप में। clipped सैंपल 32767 और −32768 निकले।
2.  **Chromium में ब्राउज़र वाला रास्ता।** Playwright ने नक़ली माइक्रोफ़ोन के साथ headless Chromium चलाया। `startRecording` ने 3 सेकंड `audio/webm;codecs=opus` (40,563 बाइट) में रिकॉर्ड किए, और `toWav16k` ने उसे 96,044 बाइट के WAV में बदला: 3.0 सेकंड, 16 kHz, मोनो।
3.  **प्रॉक्सी।** WAV और कच्चे WebM, दोनों ने 200 लौटाया। mock को हर बार `Bearer` auth, अरबी मॉडल ID, `language=ar` और 16 kHz मोनो `audio/wav` फ़ाइल मिली; WebM को ffmpeg ने सर्वर पर बदला। 26,214,401 बाइट के WAV को upstream कॉल के बिना 413 मिला। जो बॉडी ऑडियो नहीं थी, उसे 400 मिला।
4.  **असुरक्षित origin।** मशीन के LAN पते से सादे HTTP पर लोड करने पर पेज ने `isSecureContext` false बताया, और `startRecording` ने `TypeError` की जगह हमारा HTTPS वाला मैसेज फेंका।

हमने Safari या Firefox टेस्ट नहीं किए, न ही कोई असली ट्रांसक्रिप्शन। शिप करने से पहले किसी असली iPhone पर आज़माएँ।

## इसकी लागत कितनी है?

BroadNet ट्रांसक्रिप्शन का बिल प्रति ऑडियो मिनट बनाता है: Transcribe Arabic के लिए $0.0042 और मल्टीलिंगुअल मॉडल के लिए $0.002। अरबी वॉइस मैसेज का एक घंटा $0.25 है। दोनों $5 के शुरुआती क्रेडिट पर चलते हैं, जो अरबी के लगभग 1,190 मिनट कवर करता है। अपनी मात्रा के लिए [speech-to-text लागत कैलकुलेटर](https://broadrouter.com/tools/speech-to-text-cost-calculator/) इस्तेमाल करें। [अरबी speech-to-text ख़रीदार गाइड](https://broadrouter.com/hi/blog/arabic-speech-to-text-api-buyers-guide/) प्रोवाइडरों की तुलना करती है।

## BroadNet Inference कहाँ फ़िट होता है

BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference अपलोड की गई फ़ाइलें ट्रांसक्राइब करता है: WAV या MP3, हर फ़ाइल के लिए एक अनुरोध, और टेक्स्ट वाला JSON रिस्पॉन्स। यह लाइव या स्ट्रीमिंग ट्रांसक्रिप्शन, टाइमस्टैम्प या स्पीकर लेबल का कोई डॉक्युमेंटेशन नहीं देता। अगर आपके ऐप में यूज़र के बोलते समय ही शब्द दिखने चाहिए, तो स्ट्रीमिंग speech API वाला प्रोवाइडर इस्तेमाल करें। वॉइस मैसेज, नोट्स और फ़ॉर्म के लिए, जहाँ यूज़र पहले रिकॉर्ड करता है और फिर भेजता है, ऊपर वाला अपलोड फ़्लो काफ़ी है। सेटअप [अरबी speech-to-text API गाइड](https://broadrouter.com/hi/guides/arabic-speech-to-text-api/) में है, और [API रेफ़रंस](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-record-browser-audio-transcription-api&utm_content=body) फ़ील्ड लिस्ट करता है। उसका प्राइवेसी स्टेटमेंट कहता है कि ऑडियो और ट्रांसक्रिप्ट रखे नहीं जाते।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[WAV फ़ाइल (WAV)](https://broadrouter.com/hi/glossary/wav/)

WAV (Waveform Audio File Format, या WAVE) Microsoft और IBM के RIFF फ़ॉर्मैट पर बना एक ऑडियो कंटेनर है। इसमें आम तौर पर बिना कंप्रेशन वाले linear PCM सैंपल होते हैं, इसलिए इसका साइज़ पहले से पता होता है: प्रति सेकंड सैंपल रेट गुणा प्रति सैंपल बाइट गुणा चैनल।

[स्पीच-टू-टेक्स्ट (speech-to-text)](https://broadrouter.com/hi/glossary/speech-to-text/)

स्पीच-टू-टेक्स्ट, जिसे automatic speech recognition (ASR) भी कहते हैं, बोले गए ऑडियो को लिखित टेक्स्ट में बदलने की तकनीक है। speech-to-text API ऑडियो फ़ाइल या स्ट्रीम लेकर ट्रांसक्रिप्ट लौटाता है, आम तौर पर प्रति ऑडियो मिनट की कीमत पर। सटीकता वर्ड एरर रेट से मापी जाती है और लहजे, बोली और रिकॉर्डिंग क्वालिटी के साथ बदलती है।

[Prefill और decode](https://broadrouter.com/hi/glossary/prefill-and-decode/)

Prefill और decode LLM इन्फ़रेंस के दो चरण हैं। Prefill में मॉडल पूरा प्रॉम्प्ट समानांतर रूप से प्रोसेस करके अपना KV cache भरता है; decode में वह उसी cache को दोबारा इस्तेमाल करते हुए जवाब एक-एक टोकन करके बनाता है। Prefill मुख्य रूप से पहले टोकन तक का समय तय करता है; decode आउटपुट की रफ़्तार।

[API key](https://broadrouter.com/hi/glossary/api-key/)

API key एक गुप्त स्ट्रिंग है जो API कॉल करने वाले क्लाइंट को पहचानती और अधिकृत करती है। LLM API आम तौर पर इसे Authorization: Bearer हेडर में चाहते हैं, और जिसके पास भी यह key हो, वह ऐसे अनुरोध कर सकता है जिनका बिल key वाले अकाउंट पर बनता है।

[Ogg Opus](https://broadrouter.com/hi/glossary/ogg-opus/)

Ogg Opus वह ऑडियो है जो Opus codec (RFC 6716) से एन्कोड होकर Ogg कंटेनर (RFC 7845) में रखा जाता है। यह कम bitrate पर बोली और इंटरैक्टिव ऑडियो के लिए बना है, और WhatsApp वॉइस नोट के लिए यही फ़ॉर्मैट इस्तेमाल करता है, आम तौर पर .ogg या .opus फ़ाइलों के रूप में।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[रेट लिमिट (rate limit)](https://broadrouter.com/hi/glossary/rate-limit/)

रेट लिमिट वह सीमा है जो कोई API तय करता है कि एक क्लाइंट किसी समय-अवधि में उसका कितना इस्तेमाल कर सकता है, जैसे प्रति मिनट अनुरोध या प्रति मिनट टोकन। सीमा से ऊपर के अनुरोध ठुकरा दिए जाते हैं, आम तौर पर HTTP 429 Too Many Requests के साथ, जब तक इस्तेमाल फिर सीमा के नीचे न आ जाए।

[सैंपल रेट (sample rate)](https://broadrouter.com/hi/glossary/sample-rate/)

सैंपल रेट हर सेकंड रिकॉर्ड होने वाले ऑडियो सैंपल की संख्या है, जिसे हर्ट्ज़ (Hz) में नापा जाता है। स्पीच रिकग्निशन मॉडल आम तौर पर 16,000 Hz (16 kHz) मोनो ऑडियो की उम्मीद करते हैं। बिट डेप्थ और चैनल संख्या के साथ मिलकर सैंपल रेट तय करता है कि बिना कंप्रेशन वाली ऑडियो फ़ाइल प्रति मिनट कितनी बड़ी होगी।

## अक्सर पूछे जाने वाले सवाल

### क्या मैं MediaRecorder की WebM फ़ाइल सीधे speech-to-text API को भेज सकता हूँ?

सिर्फ़ तब, जब API WebM लेता हो। OpenAI का ट्रांसक्रिप्शन एंडपॉइंट अपने फ़ॉर्मैट में webm और mp4 लिस्ट करता है। BroadNet सिर्फ़ WAV और MP3 लेता है, इसलिए पहले बदलें: ब्राउज़र में Web Audio API से, या अपने सर्वर पर ffmpeg -i in.webm -ar 16000 -ac 1 out.wav से।

### getUserMedia यह क्यों कहता है कि navigator.mediaDevices undefined है?

पेज secure context नहीं है। MDN के अनुसार getUserMedia सिर्फ़ HTTPS पर, localhost पर या file URL से चलता है। किसी दूसरे होस्ट से सादे HTTP पर navigator.mediaDevices मौजूद ही नहीं होता। पेज HTTPS पर सर्व करें; डेवलपमेंट के लिए localhost ठीक है।

### 25 MB के अपलोड में WAV के रूप में कितनी लंबी रिकॉर्डिंग आती है?

16 kHz मोनो 16-bit WAV प्रति सेकंड 32,000 बाइट है, ऊपर से 44 बाइट का हेडर। BroadNet की 26,214,400 बाइट की सीमा में लगभग 819 सेकंड, यानी 13 मिनट 39 सेकंड आते हैं। MP3 या कम sample rate में ज़्यादा आता है; लंबे ऑडियो को टुकड़ों में बाँटें।

### iPhone पर ख़ाली रिकॉर्डिंग से "Thank you" या "Bye" क्यों मिलता है?

OpenAI फ़ोरम पर डेवलपर बताते हैं कि ख़ामोश या टूटी रिकॉर्डिंग से छोटे गढ़े हुए वाक्य आते हैं, और iOS वाले मामलों की वजह ख़ाली dataavailable chunk निकली; size 0 वाले chunk हटाने और recorder को timeslice के साथ शुरू करने से उनकी समस्या ठीक हुई। अपलोड से पहले अवधि जाँचें।

### क्या ब्राउज़र को सीधे ट्रांसक्रिप्शन API कॉल करना चाहिए?

नहीं। फ़्रंटएंड कोड में जो कुछ है, API key समेत, उसे यूज़र पढ़ सकता है। ऑडियो अपने एंडपॉइंट पर भेजें, जो साइज़ और टाइप जाँचे, environment variable से key जोड़े और उसे आगे भेजे।

## आगे पढ़ें

-   [25 MB से बड़ा लंबा ऑडियो ट्रांसक्राइब करें: बाँटें, भेजें, जोड़ें](https://broadrouter.com/hi/blog/transcribe-long-audio-files-api/)
-   [Whisper API का विकल्प: कब बदलें, और उसे कैसे टेस्ट करें](https://broadrouter.com/hi/blog/whisper-api-alternative/)
-   [मल्टीलिंगुअल speech-to-text API: 14 भाषाएँ, एक एंडपॉइंट](https://broadrouter.com/hi/blog/multilingual-speech-to-text-api/)
-   [LLM API key को सुरक्षित कैसे रखें: स्टोरेज, रोटेशन और IP allow-list](https://broadrouter.com/hi/blog/llm-api-key-security/)
-   [अरबी speech-to-text API: 2026 में सही API कैसे चुनें](https://broadrouter.com/hi/blog/arabic-speech-to-text-api-buyers-guide/)
-   [बिज़नेस के लिए वॉइस नोट से टेक्स्ट: WhatsApp और Telegram से टिकट](https://broadrouter.com/hi/blog/voice-notes-to-text-for-business/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: API से WhatsApp वॉइस नोट को टेक्स्ट में बदलें](https://broadrouter.com/hi/guides/transcribe-whatsapp-voice-notes/)
-   [गाइड: अरबी speech-to-text API, स्टेप बाय स्टेप](https://broadrouter.com/hi/guides/arabic-speech-to-text-api/)
-   [गाइड: BroadNet Inference के साथ OpenAI Node.js SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-node-sdk/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-record-browser-audio-transcription-api&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: WAV (audio/wav) या MP3 (audio/mpeg), 26,214,400 बाइट तक, language हमेशा भेजें, text वाला JSON रिस्पॉन्स (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-record-browser-audio-transcription-api&utm_content=sources)
-   [MDN, MediaDevices.getUserMedia(): सिर्फ़ secure context, यूज़र की अनुमति, NotAllowedError (जाँचा गया 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)
-   [MDN, MediaRecorder.isTypeSupported(): true का मतलब यह गारंटी नहीं कि रिकॉर्डिंग सफल होगी (जाँचा गया 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/isTypeSupported_static)
-   [MDN, MediaRecorder dataavailable इवेंट: timeslice, stop() और अनिश्चित अंतराल (जाँचा गया 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/dataavailable_event)
-   [MDN, BaseAudioContext.decodeAudioData(): context की रेट पर resample, सिर्फ़ पूरी फ़ाइलें (जाँचा गया 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/decodeAudioData)
-   [MDN, OfflineAudioContext() constructor: sampleRate 3,000 से 768,000 Hz तक (जाँचा गया 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext/OfflineAudioContext)
-   [WebKit ब्लॉग, MediaRecorder API: Safari H.264 वीडियो और AAC ऑडियो के साथ MP4 रिकॉर्ड करता है, फ़ॉर्मैट रनटाइम पर पता चलते हैं (जाँचा गया 2026-11-15)](https://webkit.org/blog/11353/mediarecorder-api/)
-   [OpenAI speech to text गाइड: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav और webm, 25 MB तक की फ़ाइलें (जाँचा गया 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [OpenAI Developer Community, "MediaRecorder API w/ Whisper not working on mobile browsers", जुलाई से दिसंबर 2024 (जाँचा गया 2026-11-15)](https://community.openai.com/t/mediarecorder-api-w-whisper-not-working-on-mobile-browsers/866019)
