वेब ऐप में वॉइस मैसेज रिकॉर्ड करने के लिए लगभग तीस लाइन 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 बताता है); हमारे टेस्ट में 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, localhost या file: URL। किसी दूसरे होस्ट से सादे HTTP पर navigator.mediaDevices undefined होता है, इसलिए उसे कॉल करने पर अनुमति माँगने की जगह TypeError आता है। दूसरा, यूज़र को अनुमति देनी होती है, और मना करने पर NotAllowedError आता है। दोनों को ऐसे मैसेज के साथ संभालें जिस पर यूज़र कुछ कर सके।
// 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 तक कोई भी रेट लेता है।
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 देखें।
साइज़ का हिसाब मायने रखता है, क्योंकि WAV कंप्रेस्ड नहीं होता। प्रति सेकंड 16,000 सैंपल, हर एक 2 बाइट, यानी प्रति सेकंड 32,000 बाइट। 44 बाइट के हेडर के साथ BroadNet की 26,214,400 बाइट की सीमा में 819 सेकंड आते हैं: लगभग 13 मिनट 39 सेकंड। इससे लंबी किसी भी चीज़ के लिए रिकॉर्डिंग को एक सीमा पर रोकें, या सर्वर पर बाँटें, जैसा लंबी ऑडियो फ़ाइलें ट्रांसक्राइब करना में बताया गया है। ऑडियो स्प्लिटर ffmpeg कमांड लिख देता है।
ब्राउज़र में कन्वर्ज़न यूज़र का CPU और मेमोरी ख़र्च करता है, और पूरी डिकोड की हुई क्लिप 32-bit float के रूप में मेमोरी में रहती है। कुछ मिनट के वॉइस मैसेज के लिए यह ठीक है। लंबी रिकॉर्डिंग के लिए कंप्रेस्ड फ़ाइल अपलोड करें और सर्वर पर बदलें।
इसकी जगह सर्वर पर कैसे बदलें?
कंप्रेस्ड रिकॉर्डिंग जैसी है वैसी भेजें और काम ffmpeg को करने दें। पेज में कम कोड, छोटा अपलोड, और नतीजा वही:
ffmpeg -i in.webm -ar 16000 -ac 1 out.wav
अपलोड को ffmpeg में पाइप करने की जगह एक अस्थायी फ़ाइल में लिखें। MP4 फ़ाइलें अपना इंडेक्स आख़िर में रख सकती हैं, और ffmpeg उन्हें पाइप से हमेशा नहीं पढ़ पाता। WhatsApp वॉइस नोट गाइड .ogg फ़ाइलों के लिए यही कमांड इस्तेमाल करती है।
API key को ब्राउज़र से बाहर कैसे रखें?
पेज और API के बीच एक छोटा एंडपॉइंट रखें। वह रिकॉर्डिंग लेता है, ज़रूरत हो तो बदलता है, साइज़ जाँचता है, environment variable से key जोड़ता है और आगे भेजता है। Node 18 और उसके बाद के वर्शन में fetch, FormData और Blob पहले से मौजूद हैं, इसलिए इसके लिए कोई पैकेज नहीं चाहिए:
// 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 भेजता है या कच्ची रिकॉर्डिंग:
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 सुरक्षा में हैं, और BroadNet की keys को IP allow-list से सीमित किया जा सकता है। - लगभग ख़ामोश क्लिप अस्वीकार करें। फ़ोरम पर गढ़े हुए “Thank you” या “Bye” ट्रांसक्रिप्ट की रिपोर्टें ख़ामोश या टूटी रिकॉर्डिंग से जुड़ी हैं। भुगतान करने से पहले अवधि (WAV बाइट ÷ 32,000) और, हो सके तो, सिग्नल लेवल जाँचें।
हमने इसे कैसे टेस्ट किया?
कोई BroadNet key इस्तेमाल नहीं हुई। 2026-11-15 को हमने ऊपर वाला कोड /v1/audio/transcriptions के एक लोकल mock पर चलाया:
- 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 निकले। - Chromium में ब्राउज़र वाला रास्ता। Playwright ने नक़ली माइक्रोफ़ोन के साथ headless Chromium चलाया।
startRecordingने 3 सेकंडaudio/webm;codecs=opus(40,563 बाइट) में रिकॉर्ड किए, औरtoWav16kने उसे 96,044 बाइट के WAV में बदला: 3.0 सेकंड, 16 kHz, मोनो। - प्रॉक्सी। WAV और कच्चे WebM, दोनों ने 200 लौटाया। mock को हर बार
Bearerauth, अरबी मॉडल ID,language=arऔर 16 kHz मोनोaudio/wavफ़ाइल मिली; WebM को ffmpeg ने सर्वर पर बदला। 26,214,401 बाइट के WAV को upstream कॉल के बिना 413 मिला। जो बॉडी ऑडियो नहीं थी, उसे 400 मिला। - असुरक्षित origin। मशीन के LAN पते से सादे HTTP पर लोड करने पर पेज ने
isSecureContextfalse बताया, औरstartRecordingनेTypeErrorकी जगह हमारा HTTPS वाला मैसेज फेंका।
हमने Safari या Firefox टेस्ट नहीं किए, न ही कोई असली ट्रांसक्रिप्शन। शिप करने से पहले किसी असली iPhone पर आज़माएँ।
इसकी लागत कितनी है?
BroadNet ट्रांसक्रिप्शन का बिल प्रति ऑडियो मिनट बनाता है: Transcribe Arabic के लिए $0.0042 और मल्टीलिंगुअल मॉडल के लिए $0.002। अरबी वॉइस मैसेज का एक घंटा $0.25 है। दोनों $5 के शुरुआती क्रेडिट पर चलते हैं, जो अरबी के लगभग 1,190 मिनट कवर करता है। अपनी मात्रा के लिए speech-to-text लागत कैलकुलेटर इस्तेमाल करें। अरबी speech-to-text ख़रीदार गाइड प्रोवाइडरों की तुलना करती है।
BroadNet Inference कहाँ फ़िट होता है
BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference अपलोड की गई फ़ाइलें ट्रांसक्राइब करता है: WAV या MP3, हर फ़ाइल के लिए एक अनुरोध, और टेक्स्ट वाला JSON रिस्पॉन्स। यह लाइव या स्ट्रीमिंग ट्रांसक्रिप्शन, टाइमस्टैम्प या स्पीकर लेबल का कोई डॉक्युमेंटेशन नहीं देता। अगर आपके ऐप में यूज़र के बोलते समय ही शब्द दिखने चाहिए, तो स्ट्रीमिंग speech API वाला प्रोवाइडर इस्तेमाल करें। वॉइस मैसेज, नोट्स और फ़ॉर्म के लिए, जहाँ यूज़र पहले रिकॉर्ड करता है और फिर भेजता है, ऊपर वाला अपलोड फ़्लो काफ़ी है। सेटअप अरबी speech-to-text API गाइड में है, और API रेफ़रंस फ़ील्ड लिस्ट करता है। उसका प्राइवेसी स्टेटमेंट कहता है कि ऑडियो और ट्रांसक्रिप्ट रखे नहीं जाते।
