How to time-stretch a recording in your browser
- Step 1Open the tool in your browser — No download or extension needed. The page loads the FFmpeg WASM core into the tab the first time you run a job.
- Step 2Drop your recording in — Add a voice memo, interview, or field recording (m4a, mp3, wav, flac, ogg, opus, aiff). It's read into the in-page FFmpeg sandbox — not sent anywhere.
- Step 3Choose what the re-time is for — Slowing to catch detail → factor below 1 (e.g. 0.8). Speeding up to review faster → factor above 1 (e.g. 1.3). Pitch stays natural either way.
- Step 4Enter the factor — Type the speed factor in the Factor input (0.25–4, step 0.05). Output length = original ÷ factor. Default 1 leaves it unchanged.
- Step 5Process locally — FFmpeg applies
atempo=<factor>on your CPU and re-encodes in the recording's own format. Larger files take longer because the work happens on your machine, not a server farm. - Step 6Download — the file never left — Save the
-stretchedrecording. Because everything ran locally, there's no server copy to delete and no upload to worry about.
Where the work happens (browser-native pipeline)
Every stage of a stretch runs inside your browser tab. No stage touches a remote server with your audio content.
| Stage | Where it runs | Touches a server? |
|---|---|---|
| Load FFmpeg core | Browser (WASM, cached after first load) | Static asset fetch only — no audio |
| Read your recording | Browser memory / FFmpeg FS | No |
| Apply atempo + re-encode | Your CPU via WebAssembly | No |
| Return the file | Browser download | No |
| Usage counter (signed in) | Server | Count only — no file content |
Factor → speed → duration
Factor reference for recordings. Below 1 lengthens (catch detail); above 1 shortens (review faster).
| Factor | Playback speed | Output duration | atempo stages |
|---|---|---|---|
| 0.25 | Quarter speed (slowest) | 4× longer | Two (0.5 × 0.5) |
| 0.5 | Half speed | 2× longer | One |
| 0.75 | 75% speed | 1.33× longer | One |
| 1.0 | Unchanged (default) | Same length | One (no-op) |
| 1.25 | 125% speed | 0.8× (20% shorter) | One |
| 1.5 | 150% speed | 0.667× (33% shorter) | One |
| 2.0 | Double speed | Half length | One |
| 4.0 | Quadruple speed (fastest) | Quarter length | One |
Tier limits for the time-stretcher
Audio-family limits read from the code (lib/tier-limits.ts). The per-file DURATION cap is separate from the file-size cap — a 35-minute voice memo well under 50 MB still exceeds the Free 30-minute limit. The time-stretcher is a Pro-tier tool (minTier: pro).
| Tier | Max file size | Max duration per file | Files per batch |
|---|---|---|---|
| Free | 50 MB | 30 min | 1 (time-stretcher itself starts at Pro) |
| Pro | 200 MB | 120 min | 10 |
| Pro-media | 100 GB (streaming) | Unlimited | 100 |
| Developer | 100 GB | Unlimited | Unlimited |
Cookbook
Recording workflows where keeping the file local matters as much as re-timing it. Factors round to the 0.05 step.
Slow a voice memo to catch a mumbled detail
A quick voice memo has a name or number you can't quite make out. Slow it to 0.8× — pitch intact — and replay the unclear part.
Input : memo.m4a (35 s) Factor : 0.80 Output : memo-stretched.m4a (35 / 0.80 = 43.8 s) Processed entirely in the browser; memo never uploaded.
Speed up a dictation to review it in less time
A 20-minute dictated note can be reviewed at 1.4× to save time, still in the dictator's natural voice.
Input : dictation.mp3 (20 min) Factor : 1.40 Output : ~14.3 min (20 / 1.40) Faster review, same pitch -- no chipmunk.
Re-time a confidential interview without uploading it
A journalist needs a 50-minute source interview slowed to 0.85× for transcription, but can't put it on a third-party server.
Input : source-interview.wav (50 min) Factor : 0.85 (slows for typing) Output : ~58.8 min wav (50 / 0.85) Runs locally on Pro/Pro-media; nothing leaves the laptop.
Field recording stretched for sound design
A nature field recording is slowed to 0.5× for an ambient bed; FLAC in, FLAC out keeps it lossless through the in-browser pipeline.
Input : forest.flac Factor : 0.50 Output : forest-stretched.flac (2x longer, lossless) No upload of the location-tagged field tape.
Trim then stretch a long lecture recording
A 2-hour lecture only needs one 10-minute segment slowed. Trim locally first, then stretch the segment — smaller render, still nothing uploaded.
Step 1: audio-trimmer -> segment.m4a (10 min) Step 2: time-stretcher factor 0.8 -> 12.5 min Both steps run in-browser on the segment, not the 2-hour file.
Edge cases and what actually happens
First run is slow to start
ExpectedThe browser downloads and initialises the FFmpeg WASM core on the first job. That one-time load can take a few seconds; subsequent stretches in the same session reuse the cached core and start immediately.
Big file uses a lot of memory
Local resource limitBecause processing is in-browser, a large recording must fit in the tab's memory. Very large WAVs can exhaust a low-RAM device. Close other tabs, or trim/convert first. This is a device limit, not a server one.
Recording exceeds the tier duration cap
RejectedFree caps at 30 min, Pro at 120 min per file (and this is a Pro tool). A long interview needs Pro-media for unlimited duration. The duration check is independent of file size.
Voice memo is a video container (mov/3gp)
Wrong toolSome phone memos are video containers. The time-stretcher takes audio input only. Extract the audio with video-to-mp3 first, then stretch the audio.
Safari can't decode the recording
Browser limitFLAC/Opus WASM decoding is unreliable in some Safari builds. Switch to Chrome/Edge/Firefox or convert to WAV first. The local-only guarantee holds in every browser.
Sped-up review loses clarity
Algorithm limitBeyond about 1.5×, atempo's time-stretch artefacts make speech harder to parse. For review, 1.3×–1.5× keeps words clear; push higher only if you just need the gist.
You closed the tab mid-process
No server stateBecause nothing is uploaded, closing the tab simply cancels the local job — there's no half-finished file on a server and nothing to clean up. Re-run from the original file.
MP3 voice memo re-encoded
Re-encode generationStretching re-encodes (the samples change). For speech that's inaudible. If you want the cleanest archival copy, stretch a WAV source and convert to MP3 last.
Frequently asked questions
Is my recording uploaded to a server?
No. The time-stretcher runs FFmpeg as WebAssembly inside your browser tab. Your recording is read, processed on your own CPU, and downloaded — it never leaves your machine. Only an anonymous job counter is stored when you're signed in.
Do I need to install anything?
No. It runs in any modern browser. The FFmpeg core loads into the page on first use; after that it's cached for the session.
Can I use it offline?
Once the page and the FFmpeg core have loaded, the actual processing is local, so it keeps working even if your network drops mid-session. A fresh page load needs the assets first.
How do I make a recording longer to catch a detail?
Use a factor below 1 (e.g. 0.8 for 80% speed). The recording gets longer (output = original ÷ factor) and the pitch stays natural, so the speaker still sounds like themselves.
How do I review a long recording faster?
Use a factor above 1 (e.g. 1.4). The recording gets shorter while keeping pitch, so it's faster to review without the chipmunk effect. Keep it under ~1.5× for clear speech.
Will the output match my recording's format?
Yes. There's no format option; the output keeps the input extension and is re-encoded with that format's encoder (e.g. m4a→aac, wav→pcm_s16le).
How long a recording can I process?
This is a Pro feature. Pro allows 120 minutes per file; Pro-media and Developer remove the duration cap and allow files up to 100 GB. The duration cap is separate from the size cap.
Why does a big file take a while?
All the work happens on your device, not a server. Larger files mean more local CPU and memory, so they take longer and use more RAM. Trimming to the part you need speeds things up.
Is there a server copy I should delete afterward?
No. Nothing is uploaded, so there's no server-side copy of your recording to clean up. The only artefact is the file you download to your own disk.
My phone memo is a video file — can I stretch it?
Not directly; this tool takes audio input. Extract the audio first with video-to-mp3 or video-to-wav, then stretch the extracted audio.
Can I stretch just part of a long recording?
Yes — trim the segment with audio-trimmer first, then stretch the smaller clip. Both steps run locally, so even the original long file is never uploaded.
Does it change the pitch at all?
No. FFmpeg's atempo holds pitch constant while changing tempo. Very large factors add time-stretch artefacts, but the pitch centre doesn't move.
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.