BroadRouter

براؤزر میں آڈیو ریکارڈ کریں اور speech-to-text API کو بھیجیں

BroadNet Inference ٹیم · 6 منٹ کی پڑھائی · شائع شدہ

getUserMedia اور MediaRecorder سے ریکارڈ کریں، isTypeSupported سے فارمیٹ چنیں اور خالی chunks ہٹا دیں۔ اگر API صرف WAV یا MP3 لیتا ہے تو براؤزر میں ڈی کوڈ کر کے 16 kHz مونو WAV بنائیں، یا سرور پر ffmpeg سے بدلیں۔ دونوں صورتوں میں اپنے بیک اینڈ کے ذریعے بھیجیں تاکہ API کلید کبھی براؤزر تک نہ پہنچے۔

ویب ایپ میں وائس میسج ریکارڈ کرنے کے لیے تقریباً تیس لائن JavaScript کافی ہے۔ مسئلے فائل بھیجتے وقت شروع ہوتے ہیں: براؤزر نے WebM یا MP4 ریکارڈ کیا، API کچھ اور چاہتا ہے، iPhone خاموش کلپ پر “Thank you” لوٹاتا ہے، اور جو ٹیوٹوریل آپ نے کاپی کیا وہ API کلید صفحے ہی میں رکھ دیتا ہے۔ یہ پوسٹ پورا راستہ بناتی ہے اور ہر حصے کو ٹیسٹ کرتی ہے: ریکارڈ کریں، 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();
  });
}

اس کی تین باتیں حقیقی بگ رپورٹس سے آئی ہیں:

  • خالی chunks ہٹا دیں۔ iPhone پر MediaRecorder کے بارے میں OpenAI فورم کے ایک تھریڈ میں ایک ڈویلپر نے دیکھا کہ iOS پر dataavailable خالی ڈیٹا کے ساتھ فائر ہو رہا تھا، اور ان chunks کو ہٹانے سے مسئلہ حل ہوا۔ ایک اور نے یہی علامت timeslice، یعنی start(1000)، کے ساتھ شروع کر کے ٹھیک کی۔
  • ٹریکس بند کریں۔ recorder روکنے سے مائیکروفون آزاد نہیں ہوتا۔ getTracks().forEach(t => t.stop()) کے بغیر براؤزر ریکارڈنگ کا نشان دکھاتا رہتا ہے۔
  • chunks گن کر ریکارڈنگ کا وقت نہ ناپیں۔ 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 کلید کو براؤزر سے باہر کیسے رکھیں؟

صفحے اور API کے درمیان ایک چھوٹا اینڈپوائنٹ رکھیں۔ وہ ریکارڈنگ لیتا ہے، ضرورت ہو تو بدلتا ہے، سائز جانچتا ہے، environment variable سے کلید شامل کرتا ہے اور آگے بھیجتا ہے۔ 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.” لوٹاتا ہے۔
  • ڈیپلائے کرنے سے پہلے تصدیق (authentication) اور rate limit شامل کریں۔ ورنہ جسے بھی /transcribe مل جائے، وہ آپ کا بیلنس خرچ کرے گا۔ باقی باتیں LLM API کلید کی حفاظت میں ہیں، اور BroadNet کی کلیدوں کو IP allow-lists سے محدود کیا جا سکتا ہے۔
  • تقریباً خاموش کلپس مسترد کریں۔ فورم پر گھڑے ہوئے “Thank you” یا “Bye” ٹرانسکرپٹس کی رپورٹس خاموش یا ٹوٹی ہوئی ریکارڈنگز سے جڑی ہیں۔ ادائیگی سے پہلے دورانیہ (WAV بائٹس ÷ 32,000) اور، ہو سکے تو، سگنل لیول جانچیں۔

ہم نے اسے کیسے ٹیسٹ کیا؟

کوئی BroadNet کلید استعمال نہیں ہوئی۔ 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 لاگت کیلکولیٹر استعمال کریں۔ عربی speech-to-text خریدار گائیڈ فراہم کنندگان کا موازنہ کرتی ہے۔

BroadNet Inference کہاں فٹ ہوتا ہے

BroadRouter، BroadNet کی اپنی سائٹ ہے۔ BroadNet Inference اپ لوڈ کی گئی فائلیں ٹرانسکرائب کرتا ہے: WAV یا MP3، ہر فائل کے لیے ایک درخواست، اور متن والا JSON جواب۔ یہ لائیو یا اسٹریمنگ ٹرانسکرپشن، ٹائم اسٹیمپس یا اسپیکر لیبلز کی کوئی دستاویز نہیں دیتا۔ اگر آپ کی ایپ میں صارف کے بولتے وقت ہی الفاظ نظر آنے چاہییں تو اسٹریمنگ speech API والا فراہم کنندہ استعمال کریں۔ وائس میسجز، نوٹس اور فارمز کے لیے، جہاں صارف پہلے ریکارڈ کرتا ہے اور پھر بھیجتا ہے، اوپر والا اپ لوڈ فلو کافی ہے۔ سیٹ اپ عربی speech-to-text API گائیڈ میں ہے، اور API ریفرنس فیلڈز درج کرتا ہے۔ اس کا پرائیویسی بیان کہتا ہے کہ آڈیو اور ٹرانسکرپٹس محفوظ نہیں رکھے جاتے۔

عام سوالات

کیا میں 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 chunks نکلی؛ size 0 والے chunks ہٹانے اور recorder کو timeslice کے ساتھ شروع کرنے سے ان کا مسئلہ حل ہوا۔ اپ لوڈ سے پہلے دورانیہ جانچیں۔

کیا براؤزر کو سیدھا ٹرانسکرپشن API کال کرنا چاہیے؟

نہیں۔ فرنٹ اینڈ کوڈ میں جو کچھ ہے، API کلید سمیت، صارف پڑھ سکتا ہے۔ آڈیو اپنے اینڈپوائنٹ پر بھیجیں، جو سائز اور ٹائپ جانچے، environment variable سے کلید شامل کرے اور آگے بھیجے۔

Markdown میں پڑھیںChatGPT سے پوچھیںClaude سے پوچھیںPerplexity سے پوچھیں