How to anonymise a video file before sharing as evidence
- Step 1Decide what 'anonymise' must cover for this disclosure — Metadata scrubbing removes the file's tags — GPS, device, date. It does not alter the picture or audio. If the footage shows faces, screens, plates, or you can hear identifiable voices, plan separate redaction steps; metadata removal is one layer of a larger anonymisation, not the whole job.
- Step 2Work from a verified copy, preserve the original for custody — For a chain-of-custody workflow, keep the untouched original (with its hash) sealed, and scrub a working copy. The scrub produces a new file; it never modifies the input on disk, so the original remains intact for integrity verification.
- Step 3Drop the working copy onto the scrubber — FFmpeg.wasm processes it locally — the sensitive clip is never uploaded, which is exactly what you want for confidential or source-protecting material. MP4, MOV, MKV, WebM, AVI, M4V, and TS are accepted.
- Step 4Choose Mode 'all' for source protection — Default removes GPS/device/date. For evidence where you want zero residual fingerprint, choose 'all': it additionally runs
-map_chapters -1 -fflags +bitexact, removing chapter markers and suppressing the muxer's encoder/timestamp fingerprint. - Step 5Process and verify the output — Run
ffprobeon the result and confirm GPS, make/model,creation_time, andencoderare absent. Document the before/after metadata states for your record — the scrub is deterministic and the media streams are bit-identical to the working copy. - Step 6Apply picture/audio redaction if the content requires it — If faces must be hidden, run face-blur or face-pixelate; for licence plates, screens, or documents in frame, video-redactor; to silence identifiable audio, audio-mute-region. Do these on the scrubbed file before sharing.
Anonymisation layers for an evidence clip
Metadata scrubbing is one layer. Use these tools for the parts that live in the picture or audio, not the tags. Apply picture/audio redaction to the scrubbed file.
| What to hide | Where it lives | Tool |
|---|---|---|
| GPS, camera, date, software stamp | Container / stream metadata | This scrubber (-map_metadata -1) |
| Faces of bystanders or a source | Pixels (encoded frames) | face-blur / face-pixelate |
| Licence plates, screens, documents | Pixels | video-redactor |
| Identifiable voices / spoken names | Audio stream | audio-mute-region |
What the scrub removes vs preserves (integrity view)
For evidence, knowing exactly what changes matters. The media streams are bit-identical; only metadata is rewritten.
| Item | Default mode | All mode |
|---|---|---|
| GPS / camera / date / software tags | Removed | Removed |
| Title / chapter markers | Kept | Removed |
| Muxer encoder fingerprint | Input tag removed | Suppressed (bitexact) |
| Video & audio stream bytes | Bit-identical (stream-copy) | Bit-identical (stream-copy) |
| Container / codecs | Unchanged | Unchanged |
Cookbook
Evidence-workflow scenarios with before/after metadata states. All identifiers anonymised.
Full identifying block removed
A source clip carries GPS, model, date, and a software stamp. One 'all' pass clears the lot.
Before (ffprobe): com.apple.quicktime.location.ISO6709 : +xx.xxxx-xxx.xxxx/ com.apple.quicktime.make : Apple com.apple.quicktime.model : iPhone 14 creation_time : 2026-02-11T... encoder : Lavf... Scrub (Mode: all) → exhibit-A-out.mov After: (location / make / model / date / encoder all gone) Video + audio streams: bit-identical to working copy
Original sealed, working copy scrubbed
Chain-of-custody: hash and seal the original; scrub a copy. The tool never modifies the input.
1. sha256 original.mov → record hash, seal original 2. duplicate → working.mov 3. Scrub working.mov (Mode: all) → working-out.mov 4. ffprobe working-out.mov → confirm no metadata 5. Share working-out.mov; original stays sealed (The scrubber writes a NEW file; original on disk is never altered.)
Metadata clean but faces still visible
A clip with bystanders needs picture redaction in addition to the scrub.
Step 1 Scrub metadata → clip-out.mp4 (tags gone) Step 2 face-blur on clip-out → faces hidden Step 3 Share the blurred file Metadata removal alone leaves faces visible — it is one layer, not the whole anonymisation.
Long bodycam / CCTV file
Hours-long recordings are fine — there is no duration cap, only file size by tier.
Input: bodycam_shift.mp4 (3 h, 7 GB) Tier: Pro-media (100 GB cap) → accepted Scrub (Mode: all) → bodycam_shift-out.mp4 - all metadata removed - 3 hours of footage: byte-identical, not re-encoded Free tier (1 GB) would need a pre-trim first.
Verifying the scrub for the record
Document the before/after so the anonymisation is auditable.
$ ffprobe -show_format exhibit-A-out.mov | grep TAG (no TAG: lines for location/make/model/date/encoder) Stream hashes (video) before scrub == after scrub → proves the picture was not altered, only metadata.
Edge cases and what actually happens
Faces, plates, or screens visible in the footage
By designMetadata scrubbing removes tags, never pixels. Anyone or anything visible in frame stays visible. For an evidence disclosure, layer face-blur, face-pixelate, or video-redactor onto the scrubbed file before sharing.
Identifiable voices in the audio
By designThe audio stream is preserved bit-for-bit, so spoken names or recognisable voices remain. Silence the relevant spans with audio-mute-region on the scrubbed copy.
Chain-of-custody: original must stay unaltered
PreservedThe scrubber writes a new output file and never modifies the input on disk, so the sealed original is untouched. Hash the original before duplicating, scrub the working copy, and record both metadata states. The media stream bytes in the output are identical to the working copy.
A data track (telemetry / GPS stream) survives
Preserved-c copy copies every stream. If a bodycam or action cam stored GPS as a timed-data track rather than a tag, it survives the scrub. Tag-based identifiers are removed reliably; a dedicated data stream would need separate removal — verify with ffprobe for any Data: stream.
Subtitle/closed-caption stream left in place
PreservedAn embedded subtitle or caption track is a stream, not a tag, and is preserved. If captions name people or places, extract and review them with subtitle-extractor and handle separately.
Output the same size as the working copy
ExpectedStream-copy keeps the media bytes; only the small tag block is removed. Same size minus a few bytes is the expected, integrity-friendly outcome — proof nothing was re-encoded.
Corrupt or partial file won't remux
FailIf the muxer can't rewrite the container (a damaged or truncated file), the scrub exits non-zero with 'Metadata scrub failed'. For evidence, re-acquire a verified complete copy rather than working from a partial download.
File over the tier size cap
LimitFree is 1 GB per file; Pro 10 GB; Pro-media and Developer 100 GB. There is no minutes cap — long interviews and bodycam shifts are fine within the size limit. Above it, raise the tier or pre-trim with lossless-trimmer (also lossless).
Re-export after scrub re-stamps software/date
ExpectedIf the scrubbed file is later re-exported by any tool, that tool adds its own encoder and possibly a fresh creation_time. For evidence, scrub last and share that exact file, or your shared copy regains a fingerprint.
Frequently asked questions
What exactly gets removed when I anonymise a clip?
The full global metadata block: GPS location, camera make/model/firmware, creation_time, software/encoder stamp, and custom tags. With mode 'all', chapter markers and the muxer fingerprint go too. The video and audio streams are preserved byte-for-byte.
Does this alter the footage in any way?
No. It uses -c copy, so the encoded video and audio are bit-identical to the source. Only the container metadata is rewritten — which is exactly what you want for evidence, where the picture must remain unaltered.
Is the sensitive file uploaded anywhere?
No. FFmpeg.wasm runs in your browser and the file never leaves your machine. That removes the upload as a confidentiality and chain-of-custody risk — important for source protection and privileged material.
Does scrubbing metadata hide faces or voices?
No. Metadata removal does not touch pixels or audio. Faces stay visible (use face-blur / face-pixelate), on-screen text stays (video-redactor), and voices remain (audio-mute-region). Scrubbing is one anonymisation layer of several.
Will my sealed original be modified?
No. The tool writes a new output file and never alters the input on disk. Hash and seal the original, scrub a working copy, and you retain an unmodified original for integrity verification.
Should I use default or all mode for evidence?
Use 'all' for maximum source protection: it adds -map_chapters -1 -fflags +bitexact, removing chapters and suppressing the muxer's encoder/timestamp fingerprint. Default already removes GPS, device, and date but keeps chapters.
Could a GPS data track survive the scrub?
Yes, if the camera stored GPS as a timed-data stream rather than a tag. -c copy preserves all streams. Tag-based location is removed reliably; check ffprobe for any Data: stream and remove it separately if present.
Are embedded subtitles or captions removed?
No — they are streams, not tags, so they are preserved. If captions name people or places, review them with subtitle-extractor and handle separately.
Can it handle a long bodycam or interview recording?
Yes. There is no duration cap — only a file-size cap by tier (Free 1 GB, Pro 10 GB, Pro-media and Developer 100 GB). Hours-long footage within the size limit scrubs without re-encoding.
How do I prove the anonymisation for the record?
Run ffprobe before and after and document that the metadata tags are gone. Because the media is stream-copied, the video/audio stream bytes are identical between working copy and output — verifiable by hashing the streams.
Why does my shared file still have an encoder tag?
Because it was re-exported after the scrub — each tool adds its own encoder (and sometimes a fresh date). Scrub the final file last and share that exact copy.
Which formats are supported and do I need software?
MP4, MOV, MKV, WebM, AVI, M4V, and TS, all kept in the same container. No FFmpeg install and no sign-in for files under the free 1 GB cap — useful on a locked-down work machine.
Privacy first
Every JAD Video tool runs entirely in your browser via WebCodecs and FFmpeg (WebAssembly). Your video files never leave your device — verified by zero outbound network requests during processing.