Mga tatlumpung linya ng JavaScript lang ang pag-record ng voice message sa web app. Nagsisimula ang problema kapag ipinadala mo na ang file: WebM o MP4 ang nai-record ng browser, iba ang gusto ng API, “Thank you” ang ibinabalik ng iPhone para sa tahimik na clip, at nasa page ang API key sa tutorial na kinopya mo. Binubuo ng post na ito ang buong daloy at tine-test ang bawat bahagi: mag-record, i-convert sa WAV, tingnan ang laki at ipasa sa maliit na server.
Para sa API na WAV o MP3 lang ang tinatanggap ang mga halimbawa. Isa rito ang BroadNet Inference: WAV (audio/wav) o MP3 (audio/mpeg) hanggang 26,214,400 byte kada file ang nakalista sa docs nito. Kung tumatanggap ng WebM ang API mo, laktawan ang conversion at gamitin ang iba. Nakalista sa speech-to-text guide ng OpenAI ang flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav at webm, hanggang 25 MB.
Anong format ang nire-record ng browser?
Compressed na format na pinili ng browser ang nire-record ng MediaRecorder, maliban kung humingi ka ng format na suportado nito. Magtanong gamit ang MediaRecorder.isTypeSupported() at kunin ang unang tugma:
| Type string | Karaniwang browser |
|---|---|
audio/webm;codecs=opus |
Chrome, Edge, Firefox |
audio/mp4 |
Safari (dokumentado ng WebKit ang MP4 na may AAC); iniulat din ito ng Chromium sa test namin |
audio/ogg;codecs=opus |
Firefox |
Sa headless Chromium noong 2026-11-15, nagbalik ang isTypeSupported ng true para sa WebM/Opus at MP4 at false para sa Ogg/Opus. Ituring ang table na panimula, hindi pangako. Paalala ng MDN na ang ibig sabihin ng true ay kaya ng browser na i-record ang type sa prinsipyo; puwede pa ring bumagsak ang recording kapag kinapos ang resources. Laging basahin ang recorder.mimeType pagkatapos itong gawin, at iyon ang ilagay na label sa upload, hindi ang hiningi mo.
Paano mag-record mula sa mikropono?
Dalawang patakaran ng browser ang humuhubog sa code. Una, umiiral lang ang getUserMedia sa secure context: HTTPS, localhost o file: URL. Sa plain HTTP mula sa ibang host, undefined ang navigator.mediaDevices, kaya TypeError ang ibinabato ng pagtawag dito sa halip na humingi ng pahintulot. Ikalawa, kailangang magbigay ng access ang user, at NotAllowedError ang lumalabas kapag tumanggi siya. Hawakan ang dalawa gamit ang mensaheng may magagawa ang user.
// 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();
});
}
Galing sa totoong bug report ang tatlong detalye rito:
- Itapon ang mga walang lamang chunk. Sa isang thread sa forum ng OpenAI tungkol sa MediaRecorder sa iPhone, nakita ng isang developer na nagfa-fire ang
dataavailablenang walang laman sa iOS, at naayos ito nang i-filter ang mga chunk na iyon. Inayos naman ng isa pa ang parehong sintomas sa pagsisimula nang may timeslice,start(1000). - Ihinto ang mga track. Hindi binibitawan ang mikropono kapag inihinto ang recorder. Kung walang
getTracks().forEach(t => t.stop()), patuloy na ipinapakita ng browser ang recording indicator. - Huwag sukatin ang haba ng recording sa pagbilang ng chunk. Babala ng MDN na hindi eksakto ang mga pagitan ng timeslice at puwedeng humaba kapag pinause ng Safari ang mikropono o ni-lock ng Android Chrome ang screen. Gumamit ng sarili mong timer kung magpapakita ka ng haba o magpapatupad ng limit.
Paano i-convert sa WAV ang recording sa browser?
Kayang i-decode ng Web Audio API ang anumang nai-record ng browser. Dalawang katotohanan mula sa MDN ang nagpapaikli nito: gumagana lang ang decodeAudioData sa buong file, hindi sa mga piraso, kaya mag-decode pagkatapos ng stop(); at nire-resample nito ang na-decode na audio sa sample rate ng context nito. Kaya ang OfflineAudioContext na ginawa sa 16,000 Hz ay nagbabalik ng 16 kHz na sample nang walang dagdag na resampling code. Tumatanggap ang constructor nito ng anumang rate mula 3,000 hanggang 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" });
}
Bakit 16 kHz mono: ito ang setting na ginagamit ng sariling ffmpeg example ng BroadNet (-ar 16000 -ac 1), napapanatili nito ang speech band, at sangkatlo lang ito ng byte ng 48 kHz. Dinodoble ng stereo ang laki nang walang pakinabang sa iisang boses. Tingnan ang sample rate para sa mga trade-off.
Mahalaga ang kuwenta ng laki, dahil uncompressed ang WAV. 16,000 sample kada segundo na tig-2 byte ay 32,000 byte kada segundo. Kasama ang 44-byte na header, 819 segundo ang kasya sa 26,214,400-byte na limit ng BroadNet: mga 13 minuto at 39 segundo. Para sa anumang mas mahaba, ihinto ang recording sa isang limit, o hatiin sa server gaya ng sa pag-transcribe ng mahahabang audio file. Ang audio splitter ang gagawa ng mga ffmpeg command.
Gumagamit ng CPU at memory ng user ang pag-convert sa browser, at nasa memory ang buong na-decode na clip bilang 32-bit float. Ayos lang iyan para sa mga voice message na ilang minuto. Para sa mahahabang recording, i-upload na lang ang compressed na file at sa server mag-convert.
Paano kung sa server mag-convert?
Ipadala ang compressed na recording nang ganoon lang at hayaang ffmpeg ang gumawa. Mas kaunting code sa page, mas maliit na upload, at pareho ang resulta:
ffmpeg -i in.webm -ar 16000 -ac 1 out.wav
Isulat ang upload sa temporary file sa halip na i-pipe ito sa ffmpeg. Puwedeng nasa dulo ang index ng mga MP4 file, at hindi laging nababasa ng ffmpeg ang mga iyon mula sa pipe. Ginagamit ng gabay sa WhatsApp voice note ang parehong command para sa mga .ogg file.
Paano ilayo ang API key sa browser?
Maglagay ng maliit na endpoint sa pagitan ng page at ng API. Tinatanggap nito ang recording, kino-convert kung kailangan, tinitingnan ang laki, idinadagdag ang key mula sa environment variable at ipinapasa ito. Built-in na ang fetch, FormData at Blob sa Node 18 pataas, kaya walang package na kailangan:
// 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);
Pagkatapos, ipinapadala ng page ang WAV o ang raw na recording:
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();
Mga puntong dapat panatilihin kapag iniangkop mo ito:
- Laging ipadala ang
language. Ayon sa docs ng BroadNet, puwedeng bumalik ang Arabic na naka-transliterate sa Latin na titik kapag wala ito. Gamitin angarsa Arabic model, o lumipat sabroadnet/cohere-transcribeat sa tamang code para sa isa sa 14 na wika nito. - Magbalik ng pangkalahatang error. Ibinabalik ng unang bersyon ng test proxy namin ang error ng ffmpeg, na may kasamang file path sa server. “Could not read the recording.” ang ibinabalik ng code sa itaas sa halip.
- Magdagdag ng authentication at rate limit bago mo i-deploy. Kung hindi, gagastusin ng sinumang makatuklas ng
/transcribeang balance mo. Ang seguridad ng LLM API key ang sumasaklaw sa iba pa, at puwedeng limitahan ang mga BroadNet key gamit ang IP allow-list. - Tanggihan ang halos tahimik na clip. Kinasasangkutan ng tahimik o sirang recording ang mga ulat sa forum ng gawa-gawang “Thank you” o “Bye” na transcript. Tingnan ang haba (byte ng WAV ÷ 32,000) at, kung kaya, ang signal level bago mo ito bayaran.
Paano namin ito tinest?
Walang BroadNet key na ginamit. Noong 2026-11-15, pinatakbo namin ang code sa itaas laban sa lokal na mock ng /v1/audio/transcriptions:
- Encoder sa Node. Gumawa ang
encodeWavng 32,044 byte mula sa isang segundo ng 440 Hz na tono na may dalawang clipped na sample. Binasa ito ngwavemodule ng Python bilang 1 channel, 16,000 Hz, 2-byte na sample, 16,000 frame, at ng ffmpeg bilangpcm_s16le, 16000 Hz, mono. Lumabas ang mga clipped na sample bilang 32767 at −32768. - Browser path sa Chromium. Pinatakbo ng Playwright ang headless Chromium na may pekeng mikropono. Nag-record ang
startRecordingng 3 segundo bilangaudio/webm;codecs=opus(40,563 byte), at ginawa itong 96,044-byte na WAV ngtoWav16k: 3.0 segundo, 16 kHz, mono. - Proxy. Parehong nagbalik ng 200 ang WAV at ang raw na WebM. Nakita ng mock ang
Bearerauth, ang model ID ng Arabic, anglanguage=arat isang 16 kHz mono naaudio/wavfile sa bawat pagkakataon; kino-convert ng ffmpeg ang WebM sa server. Nakakuha ng 413 ang 26,214,401-byte na WAV nang walang tawag sa upstream. Nakakuha ng 400 ang body na hindi audio. - Hindi secure na origin. Nang i-load mula sa LAN address ng makina sa plain HTTP, false ang iniulat ng page para sa
isSecureContextat ang mensahe naming tungkol sa HTTPS ang ibinato ngstartRecording, hindiTypeError.
Hindi namin tinest ang Safari o Firefox, o ang totoong transcription. Subukan sa totoong iPhone bago mo i-ship.
Magkano ang magagastos?
Kada minuto ng audio ang singil ng BroadNet sa transcription: $0.0042 para sa Transcribe Arabic at $0.002 para sa multilingual na model. $0.25 ang isang oras ng Arabic na voice message. Parehong tumatakbo sa $5 na panimulang credit, na sumasaklaw sa mga 1,190 minuto ng Arabic. Para sa sarili mong volume, gamitin ang speech-to-text cost calculator. Inihahambing ng gabay sa pagbili ng Arabic speech-to-text ang mga provider.
Saan pumapasok ang BroadNet Inference
Sariling website ng BroadNet ang BroadRouter. Nagta-transcribe ang BroadNet Inference ng mga in-upload na file: WAV o MP3, isang request kada file, na may JSON response na naglalaman ng text. Hindi nito dinodokumento ang live o streaming na transcription, timestamp o speaker label. Kung kailangan ng app mo na lumabas ang mga salita habang nagsasalita ang user, gumamit ng provider na may streaming speech API. Para sa voice message, notes at form, kung saan nagre-record muna ang user bago magpadala, sapat na ang upload flow sa itaas. Nasa gabay sa Arabic speech-to-text API ang setup, at nakalista sa API reference ang mga field. Ayon sa privacy statement nito, hindi itinatago ang audio at mga transcript.
