Merakam mesej suara dalam aplikasi web memerlukan kira-kira tiga puluh baris JavaScript. Masalahnya bermula apabila anda menghantar fail itu: pelayar merakam WebM atau MP4, API mahukan format lain, iPhone memulangkan “Thank you” untuk klip senyap, dan tutorial yang anda salin meletakkan kunci API dalam halaman. Catatan ini membina keseluruhan laluan dan menguji setiap bahagian: rakam, tukar kepada WAV, semak saiz dan majukan melalui pelayan kecil.
Contoh-contoh ini menyasarkan API yang hanya menerima WAV atau MP3. BroadNet Inference ialah salah satu: dokumentasinya menyenaraikan WAV (audio/wav) atau MP3 (audio/mpeg) sehingga 26,214,400 bait setiap fail. Jika API anda menerima WebM, langkau penukaran dan kekalkan yang lain. Panduan speech-to-text OpenAI menyenaraikan flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav dan webm, sehingga 25 MB.
Format apakah yang dirakam oleh pelayar?
MediaRecorder merakam format termampat yang dipilih pelayar, melainkan anda meminta format yang disokongnya. Tanya dengan MediaRecorder.isTypeSupported() dan ambil padanan pertama:
| Rentetan jenis | Pelayar biasa |
|---|---|
audio/webm;codecs=opus |
Chrome, Edge, Firefox |
audio/mp4 |
Safari (WebKit mendokumenkan MP4 dengan AAC); Chromium juga melaporkannya dalam ujian kami |
audio/ogg;codecs=opus |
Firefox |
Dalam Chromium headless pada 2026-11-15, isTypeSupported memulangkan true untuk WebM/Opus dan MP4 serta false untuk Ogg/Opus. Anggap jadual ini sebagai titik permulaan, bukan janji. MDN menyatakan bahawa true bermaksud pelayar boleh merakam jenis itu secara prinsip; rakaman masih boleh gagal jika sumber tidak mencukupi. Sentiasa baca recorder.mimeType selepas menciptanya, dan labelkan muat naik dengan nilai itu, bukan dengan apa yang anda minta.
Bagaimanakah merakam daripada mikrofon?
Dua peraturan pelayar membentuk kod ini. Pertama, getUserMedia hanya wujud dalam konteks selamat: HTTPS, localhost atau URL file:. Pada HTTP biasa dari hos lain, navigator.mediaDevices ialah undefined, jadi memanggilnya mencetuskan TypeError dan bukannya meminta kebenaran. Kedua, pengguna mesti memberi akses, dan penolakan mencetuskan NotAllowedError. Kendalikan kedua-duanya dengan mesej yang boleh diambil tindakan oleh pengguna.
// 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();
});
}
Tiga butiran di dalamnya datang daripada laporan pepijat sebenar:
- Buang cebisan kosong. Dalam satu bebenang forum OpenAI tentang MediaRecorder pada iPhone, seorang pembangun mendapati
dataavailabledicetuskan dengan data kosong pada iOS, dan menapis cebisan itu menyelesaikannya. Seorang lagi menyelesaikan gejala yang sama dengan bermula menggunakan timeslice,start(1000). - Hentikan trek. Menghentikan perakam tidak melepaskan mikrofon. Tanpa
getTracks().forEach(t => t.stop())pelayar terus menunjukkan penunjuk rakaman. - Jangan ukur tempoh rakaman dengan mengira cebisan. MDN memberi amaran bahawa selang timeslice tidak tepat dan boleh memanjang apabila Safari menjeda mikrofon atau Chrome Android mengunci skrin. Gunakan pemasa sendiri jika anda memaparkan tempoh atau menguatkuasakan had.
Bagaimanakah menukar rakaman kepada WAV dalam pelayar?
Web Audio API boleh menyahkod apa sahaja yang dirakam oleh pelayar. Dua fakta daripada MDN memendekkan langkah ini: decodeAudioData hanya berfungsi pada fail lengkap, bukan serpihan, jadi nyahkod selepas stop(); dan ia mensampel semula audio yang dinyahkod kepada kadar sampel konteksnya. Oleh itu, OfflineAudioContext yang dicipta pada 16,000 Hz memulangkan sampel 16 kHz tanpa kod pensampelan semula tambahan. Pembinanya menerima sebarang kadar dari 3,000 hingga 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" });
}
Mengapa mono 16 kHz: ia tetapan yang digunakan oleh contoh ffmpeg BroadNet sendiri (-ar 16000 -ac 1), ia mengekalkan jalur pertuturan, dan saiznya satu pertiga daripada 48 kHz. Stereo menggandakan saiz tanpa faedah untuk satu suara. Lihat kadar sampel untuk pertukarannya.
Pengiraan saiz penting, kerana WAV tidak dimampatkan. 16,000 sampel sesaat pada 2 bait setiap satu ialah 32,000 bait sesaat. Dengan pengepala 44 bait, had 26,214,400 bait BroadNet memuatkan 819 saat: kira-kira 13 minit 39 saat. Untuk apa-apa yang lebih panjang, hentikan rakaman pada satu had, atau pecahkan di pelayan seperti dalam mentranskripsi fail audio panjang. Pemecah audio menulis arahan ffmpeg untuk anda.
Penukaran dalam pelayar menggunakan CPU dan memori pengguna, dan keseluruhan klip yang dinyahkod berada dalam memori sebagai float 32-bit. Itu tidak mengapa untuk mesej suara beberapa minit. Untuk rakaman panjang, muat naik fail termampat dan tukar di pelayan.
Bagaimanakah menukar di pelayan pula?
Hantar rakaman termampat seadanya dan biarkan ffmpeg melakukan kerja. Kurang kod dalam halaman, muat naik lebih kecil, dan hasil yang sama:
ffmpeg -i in.webm -ar 16000 -ac 1 out.wav
Tulis muat naik ke fail sementara dan bukannya menyalurkannya (pipe) ke ffmpeg. Fail MP4 boleh menyimpan indeksnya di hujung, dan ffmpeg tidak selalu dapat membacanya daripada pipe. Panduan nota suara WhatsApp menggunakan arahan yang sama untuk fail .ogg.
Bagaimanakah menjauhkan kunci API daripada pelayar?
Letakkan endpoint kecil di antara halaman dan API. Ia menerima rakaman, menukarnya jika perlu, menyemak saiz, menambah kunci daripada pembolehubah persekitaran dan memajukannya. Node 18 dan ke atas mempunyai fetch, FormData dan Blob terbina dalam, jadi tiada pakej diperlukan:
// 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);
Halaman kemudian menghantar sama ada WAV atau rakaman mentah:
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();
Perkara yang patut dikekalkan apabila anda menyesuaikannya:
- Sentiasa hantar
language. Dokumentasi BroadNet menyatakan bahasa Arab boleh kembali dalam transliterasi huruf Rumi tanpanya. Gunakanardengan model bahasa Arab, atau tukar kepadabroadnet/cohere-transcribedan kod yang betul untuk salah satu daripada 14 bahasanya. - Pulangkan ralat umum. Versi pertama proksi ujian kami memaparkan semula ralat ffmpeg, yang termasuk laluan fail pelayan. Kod di atas memulangkan “Could not read the recording.” sebagai gantinya.
- Tambah pengesahan dan had kadar sebelum anda melancarkannya. Jika tidak, sesiapa yang menemui
/transcribeakan menghabiskan baki anda. Keselamatan kunci API LLM merangkumi selebihnya, dan kunci BroadNet boleh dihadkan dengan senarai benar IP. - Tolak klip yang hampir senyap. Laporan forum tentang transkrip rekaan “Thank you” atau “Bye” melibatkan rakaman senyap atau rosak. Semak tempoh (bait WAV ÷ 32,000) dan, jika boleh, aras isyarat sebelum anda membayarnya.
Bagaimanakah kami mengujinya?
Tiada kunci BroadNet digunakan. Pada 2026-11-15 kami menjalankan kod di atas terhadap olokan (mock) tempatan /v1/audio/transcriptions:
- Pengekod dalam Node.
encodeWavpada satu saat nada 440 Hz dengan dua sampel terpotong menghasilkan 32,044 bait. ModulwavePython membacanya sebagai 1 saluran, 16,000 Hz, sampel 2 bait, 16,000 bingkai, dan ffmpeg sebagaipcm_s16le, 16000 Hz, mono. Sampel terpotong keluar sebagai 32767 dan −32768. - Laluan pelayar dalam Chromium. Playwright melancarkan Chromium headless dengan mikrofon palsu.
startRecordingmerakam 3 saat sebagaiaudio/webm;codecs=opus(40,563 bait), dantoWav16kmenukarnya kepada WAV 96,044 bait: 3.0 saat, 16 kHz, mono. - Proksi. WAV dan WebM mentah kedua-duanya memulangkan 200. Olokan itu menerima pengesahan
Bearer, ID model bahasa Arab,language=ardan failaudio/wavmono 16 kHz setiap kali; ffmpeg menukar WebM di pelayan. WAV 26,214,401 bait mendapat 413 tanpa panggilan huluan. Badan yang bukan audio mendapat 400. - Asal tidak selamat. Apabila dimuatkan dari alamat LAN mesin melalui HTTP biasa, halaman melaporkan
isSecureContextfalse danstartRecordingmencetuskan mesej HTTPS kami, bukanTypeError.
Kami tidak menguji Safari atau Firefox, atau transkripsi sebenar. Cuba pada iPhone sebenar sebelum anda melancarkannya.
Berapakah kosnya?
BroadNet mengebil transkripsi bagi setiap minit audio: $0.0042 untuk Transcribe Arabic dan $0.002 untuk model pelbagai bahasa. Sejam mesej suara bahasa Arab berkos $0.25. Kedua-duanya berjalan pada kredit permulaan $5, yang meliputi kira-kira 1,190 minit bahasa Arab. Untuk jumlah anda sendiri, gunakan kalkulator kos speech-to-text. Panduan pembeli speech-to-text bahasa Arab membandingkan penyedia.
Di mana BroadNet Inference sesuai
BroadRouter ialah laman web BroadNet sendiri. BroadNet Inference mentranskripsi fail yang dimuat naik: WAV atau MP3, satu permintaan setiap fail, dengan respons JSON yang mengandungi teks. Ia tidak mendokumenkan transkripsi langsung atau penstriman, cap masa atau label penutur. Jika aplikasi anda memerlukan perkataan muncul semasa pengguna bercakap, gunakan penyedia yang mempunyai API pertuturan penstriman. Untuk mesej suara, nota dan borang, di mana pengguna merakam dan kemudian menghantar, aliran muat naik di atas sudah mencukupi. Persediaan ada dalam panduan API speech-to-text bahasa Arab, dan rujukan API menyenaraikan medannya. Pernyataan privasinya menyatakan audio dan transkrip tidak disimpan.
