How to opus to mp3 converter — zero upload, browser-based
- Step 1Open the converter (optionally then go offline) — Load the
opus-to-mp3tool. Once the page and the FFmpeg 8.1 WASM core have loaded, you can disconnect from the network — the conversion needs no server. - Step 2Drop the sensitive Opus file — Drag your
.opus/.ogg/.webmfile onto the dropzone, or click to browse. The file is read into the tab's memory locally; no upload request is made. - Step 3Verify locality (optional but reassuring) — Open DevTools → Network before converting. You'll see the FFmpeg core load once, then no request carrying your audio out — the processing is local.
- Step 4Choose the bitrate — Pick from 320k · best, 256k, 192k · default, 128k · podcast, 64k · voice. For a recorded call or voice memo, 64–128k is transparent.
- Step 5Convert locally — Run it. FFmpeg executes
-c:a libmp3lame -b:a <bitrate> -map_metadata 0 -id3v2_version 3on your CPU and produces the MP3 in the tab. - Step 6Download — nothing was uploaded — Save the MP3. The source never left your device; there's no server copy to delete because none was ever created.
Local vs server converters — what actually happens to your file
The architectural difference that matters for confidential audio. This tool sits in the 'local' column for every row.
| Aspect | This tool (local WASM) | Typical upload converter |
|---|---|---|
| Where audio is processed | Your CPU, in the browser tab | Their server |
| Upload of the file | None | Required |
| Server-side copy retained | None created | Temp file (retention varies) |
| Works offline after load | Yes | No |
| Account required to convert | No | Sometimes |
| What's logged | A count only (no audio), for signed-in stats | Often the file + metadata |
What is and isn't local
Being precise about the privacy boundary so you can trust it for confidential material.
| Step | Local? | Notes |
|---|---|---|
| Loading the page + FFmpeg core | Network (one-time) | Static assets only — no audio involved |
| Reading your Opus file | Local | FileReader into tab memory; no upload |
| Decoding + MP3 encoding | Local | FFmpeg 8.1 WASM on your CPU |
| Downloading the MP3 | Local | Blob handed to you in-tab |
| Usage counter (signed-in) | Network | A tally only — no audio content, opt-out in settings |
Tier limits (size and duration are independent)
Even the largest free conversions are fully local — tier limits gate file size and length, not where processing happens.
| Tier | Max size | Max duration | Files / run |
|---|---|---|---|
| Free | 50 MB | 30 min | 1 |
| Pro | 200 MB | 120 min | 10 |
| Pro + Media | 100 GB | Unlimited | 100 |
| Developer | 100 GB | Unlimited | Unlimited |
Cookbook
Privacy-first workflows: confidential audio converted with no upload, including offline and air-gapped scenarios.
Confidential call recording, converted offline
A recorded client call saved as Opus that must not touch any server. Load the page, disconnect Wi-Fi, then convert — the engine is already in memory.
1. Open the tool, let FFmpeg load. 2. Disconnect the network. 3. Drop call-2026-04-02.opus (64 kbps Opus, 22 min, 6 MB). 4. Bitrate 128k → call-2026-04-02.mp3 (~20 MB). → no network request carried the audio; verified in DevTools.
Legal voice memo for a case file
A privileged voice memo that needs to be an MP3 for a case-management system. Local conversion keeps it within attorney control — nothing is uploaded.
Input: privileged-memo.opus (mono, 4:10) Bitrate: 128k · podcast FFmpeg: -i in.opus -c:a libmp3lame -b:a 128k -map_metadata 0 -id3v2_version 3 out.mp3 Output: privileged-memo.mp3 — never left the machine.
Verifying no upload happens
For a compliance review, prove the audio stays local. Open DevTools' Network panel and watch the requests during a conversion.
DevTools → Network, then convert: • ffmpeg-core.wasm / .js → loaded once (no audio) • (no XHR/fetch with the audio payload) → the only post-load network activity is the usage counter (a tally, no audio) for signed-in users — opt-out in settings.
Air-gapped machine, no account
On an isolated machine with no sign-in, the converter still works after the static assets are cached — no account is required to convert.
No sign-in. Load once (or pre-cache), then air-gap. Convert evidence.opus → evidence.mp3 fully offline. → usage counter simply isn't sent (no network, no account).
Large recording within the byte cap
Even a big local file is processed locally. A 40 MB Opus recording converts on the free tier (under the 50 MB cap) without any upload.
Input: interview.opus (40 MB, 28 min) Free tier: under 50 MB and 30 min → converts locally Bitrate: 192k → interview.mp3, all on your CPU.
Edge cases and what actually happens
Network disconnected mid-conversion
PreservedConversion runs on your CPU, so losing the network after the engine has loaded does not interrupt it. The MP3 is produced locally regardless of connectivity.
Worried the file is uploaded
By designIt isn't. Open DevTools → Network and watch: the FFmpeg core loads once, then there's no request carrying the audio out. The only post-load network call is an optional usage counter (a tally with no audio content) for signed-in users, which you can opt out of in settings.
No account / not signed in
SupportedConverting requires no account. Sign-in only affects dashboard stats and the usage counter. Anonymous, offline conversion is fully supported.
File exceeds 50 MB on the free tier
Reject (free)The free byte cap is 50 MB — enforced locally, not by an upload. A larger confidential recording needs Pro (200 MB) or Pro + Media (100 GB). Processing stays local at every tier.
Recording longer than 30 minutes on free
Reject (free)Free caps duration at 30 minutes (durationMin), independent of size. A long call needs Pro (120 min) or Pro + Media (unlimited), or split it first with audio-splitter — still entirely local.
Tab closed before download
Lost — re-runBecause nothing is stored server-side, closing the tab before you download discards the in-memory MP3. There's no server copy to recover. Re-run the conversion (the source is untouched on your disk).
Corrupt or truncated sensitive file
Decode errorA truncated Opus stream fails to demux and FFmpeg reports an error locally — no partial file is uploaded anywhere. Re-export the source and retry.
Browser without WebAssembly
Unsupported browserLocal processing depends on WASM. A current Chrome/Edge/Firefox/Safari supports it; a very old or hardened browser without WASM can't run the converter. Update the browser — the privacy model is unchanged.
Embedded tags in a sensitive file
PreservedTags and any cover art carry over to the MP3 via -map_metadata 0. If a tag itself contains sensitive text you don't want in the output, edit it with the id3-editor tool afterwards — also fully local.
Frequently asked questions
Is my file really not uploaded?
Correct. FFmpeg 8.1 is compiled to WebAssembly and runs in your browser tab. The Opus is decoded and re-encoded to MP3 on your CPU. You can verify it in DevTools → Network — there is no request that carries the audio out of the page.
Can I convert with the network disconnected?
Yes. Once the page and FFmpeg core have loaded, conversion needs no server, so you can disconnect Wi-Fi and it still works. This is ideal for air-gapped or high-sensitivity machines.
Do I need an account to convert privately?
No. Converting requires no sign-in. An account only affects dashboard stats and an optional usage counter (a tally, no audio). Anonymous use is fully private.
What exactly gets sent to a server, if anything?
Only static assets (the page and the FFmpeg core) load over the network, and — for signed-in users — a single usage counter with no audio content. The audio itself never leaves the tab. You can opt out of the counter in settings.
Is there a temporary copy of my file on your servers?
No. There's no upload, so no temp file is ever created server-side. Nothing to retain, log, or breach. The only copies are the source on your disk and the MP3 you download.
What bitrate should I use for a call recording?
64–128 kbps is transparent for speech. A recorded call is usually mono Opus at a low bitrate, so 128 kbps · podcast is a safe default and 64 kbps · voice is the smallest.
Does it keep the file's metadata?
Yes, via -map_metadata 0. If the tags contain sensitive text you'd rather strip from the output, use the id3-editor tool afterwards — it also runs locally.
What if I close the tab before downloading?
The MP3 lives only in tab memory until you download it. Closing the tab discards it (there's no server copy). Just re-run the conversion — your source file is untouched on disk.
How large a file can I convert locally?
Free: 50 MB / 30 minutes. Pro: 200 MB / 120 minutes / 10 files. Pro + Media: 100 GB / unlimited duration / 100 files. All tiers process locally — the limits gate size and length, not where the work happens.
Is this secure enough for legal/medical audio?
The audio never leaves your device, which removes the upload-exposure surface entirely. Your own device security and handling of the downloaded MP3 are still your responsibility, but there is no third-party processing of the file.
Why does the page make any network requests at all?
Only to load itself and the FFmpeg engine the first time, plus the optional usage counter. None of those carry your audio. After loading, you can go offline and convert.
Where are the platform-specific guides?
Same private engine, with export steps per app: WhatsApp at /audio-tools/solutions/convert-whatsapp-voice-to-mp3, Telegram at /audio-tools/solutions/convert-telegram-voice-note-mp3, Discord at /audio-tools/solutions/discord-voice-to-mp3-browser, and a general guide at /audio-tools/solutions/opus-to-mp3-converter-browser.
Privacy first
Every JAD Audio tool runs entirely in your browser via FFmpeg (WebAssembly) and RNNoise. Your audio files never leave your device — verified by zero outbound network requests during processing.