How to strip dji / drone gps and flight-controller tags from footage
- Step 1See what the clip is leaking first — Before scrubbing it helps to know what's there. Run the file through any 'media info' viewer or
ffprobeto list the GPSlocationtag, the DJI model/firmware strings, and the creation date this tool will strip. For a JPEG still or thumbnail extracted from the flight, exif-map-previewer plots its GPS on a map so you can see the leak directly. - Step 2Drop your drone video — Upload the MP4 or MOV straight off the SD card (MKV and WebM are also accepted). The tool infers the container from the file extension and keeps it on output — an MP4 stays an MP4, a MOV stays a MOV. No format conversion happens.
- Step 3Pick the strip mode — The only control is a Mode select with two values. default removes all GPS / model / firmware / date / encoder metadata but keeps any title and chapter markers. all additionally runs
-map_chapters -1 -fflags +bitexact, wiping chapters and the title and producing a bit-exact, deterministic file. For a clip you're publishing publicly,allleaves nothing identifying behind. - Step 4Run the scrub — FFmpeg runs
-i input -map_metadata -1 -c copy output(plus the chapter/bitexact flags inallmode). Because it's a stream-copy, no codec runs — the encoded bytes pass straight through and only the container's metadata block is rewritten clean. - Step 5Download the clean clip — Save the file — same resolution, same bitrate, same frames, with the GPS, model, and firmware tags gone. The output keeps the input's container extension, ready to upload.
- Step 6Confirm the picture was untouched — To prove the scrub changed only metadata and not a single picture byte, run the source and the output through file-integrity-monitor — the only difference lies inside the rewritten container header. Record a SHA-256 of the clean file with multi-hash-fingerprinter if you keep an archive.
Drone fingerprints in a typical DJI MP4
Tags consumer drones commonly embed in the container, and how -map_metadata -1 handles each. All of these are container/stream metadata — none are part of the encoded picture — so removing them is always lossless.
| Tag | What it reveals | Removed? | Notes |
|---|---|---|---|
| `location` (ISO 6709) | GPS latitude/longitude of the flight and, by inference, the takeoff point | Removed | Stored as a container tag; wiped wholesale, not field-by-field |
| model / device name | Exact drone model (e.g. a Mavic/Air class aircraft) | Removed | Vendor custom tags are metadata tags too and are dropped |
| firmware / flight-controller string | The software/firmware version running on the aircraft | Removed | Cleared by -map_metadata -1 along with all other tags |
| creation_time | Exact date and time of the flight | Removed | Capture timestamp goes with the rest of the metadata block |
| encoder / software stamp | The 'who processed this' Lavf/encoder string | Removed | Mode: all adds +bitexact so even FFmpeg's own version string is suppressed |
Mode option contract
The tool exposes exactly one control — a Mode select. There are no presets, no per-field toggles. These are the only two values and the exact FFmpeg arguments each produces.
| Mode | FFmpeg arguments | Keeps title / chapters? | When to use |
|---|---|---|---|
default (default) | -map_metadata -1 -c copy | Yes — title and chapter markers preserved | Removes GPS, model, firmware, date, and encoder tags while leaving any human title intact |
all | -map_metadata -1 -map_chapters -1 -fflags +bitexact -c copy | No — title and chapters wiped | Maximum anonymisation for public sharing: removes chapters, title, and encoder identifier strings via bit-exact output |
Formats, output, and tier limits
Real input formats and tier file-size limits. This security entry requires a Pro plan; processing then runs through the Video Metadata Scrubber, so video-family streaming limits apply once the file is being scrubbed.
| Property | Value |
|---|---|
| Accepted containers | MP4, MOV, MKV, WebM (AVI, M4V, and TS extensions are also recognised) |
| Output | Same container as input (extension preserved); lossless stream-copy |
| Engine | FFmpeg compiled to WebAssembly, running in your browser tab — no upload |
| Minimum plan | Pro (this tool is not on the Free tier) |
| Pro file size | Up to 10 GB per file; up to 5 files |
| Pro-media file size | Up to 100 GB per file; up to 50 files |
| Developer file size | Up to 100 GB per file; unlimited batch |
Cookbook
Concrete recipes for the drone-privacy workflow this tool is built for. The ffprobe-style listings show the metadata before and after the scrub; the footage itself is unchanged.
Strip GPS and firmware before posting a flight reel
A pilot recorded a coastal flight. The MP4 carries GPS coordinates that point back to the takeoff spot plus the drone model and firmware. Mode: default removes them while keeping the file an MP4 at full quality.
Before (ffprobe -show_format excerpt): location : +34.0195-118.4912/ model : FC-class aircraft firmware : 01.00.0510 creation_time : 2026-05-30T07:41:08.000000Z Scrub: Mode = default ffmpeg -i flight.mp4 -map_metadata -1 -c copy flight-out.mp4 After: (no location, no model, no firmware, no creation_time) Video stream: bit-identical H.265 bytes, full 4K quality
Maximum anonymisation with Mode: all
An edited drone montage still carries a title named after the location and chapter markers per scene, plus the editor's software stamp. For a public upload where nothing identifying should survive, Mode: all wipes chapters and title and suppresses encoder strings via +bitexact.
Before:
title : CliffsideHouse_Flyover
Chapter #0: 00:00 'Takeoff' Chapter #1: 01:20 'Orbit'
encoder : Lavf60.16.100
Scrub: Mode = all
ffmpeg -i montage.mov -map_metadata -1 -map_chapters -1 \
-fflags +bitexact -c copy montage-out.mov
After:
(no title, no chapters, no encoder/Lavf stamp)
Re-running on the same input produces byte-identical outputClean a folder of SD-card clips in one batch
A flight session produces a dozen segmented MP4s straight off the card, every one carrying GPS and firmware. On a Pro-media plan you can drop the batch and scrub each clip; each output keeps its own container and quality.
Inputs (Pro-media, up to 50 files): DJI_0001.MP4, DJI_0002.MP4, DJI_0003.MP4 ... Each processed: -map_metadata -1 -c copy DJI_0001.MP4 -> GPS + model + firmware tags removed DJI_0002.MP4 -> same ... All outputs: same container, same encode, fingerprints gone
Prove the footage was not re-encoded
If you archive originals and publish clean copies, you may want to show that scrubbing changed only metadata. Compare the encoded streams of source and output with file-integrity-monitor, which reports byte-equality and the first-difference offset (the only difference is the rewritten container header).
Workflow:
1. Scrub flight.mp4 -> flight-clean.mp4 (Mode: default)
2. file-integrity-monitor: drop flight.mp4 (A) + flight-clean.mp4 (B)
-> first-difference offset lies inside the moov/header,
confirming the mdat (media payload) bytes are unchanged
3. multi-hash-fingerprinter: SHA-256 the clean file for your archiveScrub an MKV proxy or screen-capture, not just MP4
If your editing pipeline produced an MKV proxy of the flight, the same engine cleans it. Matroska stores tags in its own structure and the output stays MKV.
MKV proxy:
ffmpeg -i flight-proxy.mkv -map_metadata -1 -c copy out.mkv
-> WRITING_APP, DATE_RECORDED, and custom tags removed
video/audio streams copied untouched
Note: a redacted-on-screen overlay burned into the picture
(e.g. a visible GPS HUD) is NOT metadata and stays — see edge casesEdge cases and what actually happens
Burned-in flight HUD / GPS overlay is not metadata
Not removedMany drone apps burn a visible HUD onto the picture — altitude, speed, and sometimes GPS coordinates rendered as on-screen text. That text is part of the video frames, not the metadata block, so -map_metadata -1 cannot touch it. Removing burned-in overlays requires re-encoding with a crop or blur, which is a different tool, not a metadata stripper.
MKV / WebM are fully supported
SupportedThe underlying Video Metadata Scrubber accepts MP4, MOV, MKV, and WebM, and -map_metadata -1 clears Matroska/WebM tags (WRITING_APP, DATE_RECORDED, creation_time) just like MP4-family atoms. The output stays MKV or WebM.
Audio and video streams are never altered
PreservedBecause the command is -c copy, the encoded H.264/H.265 picture and any audio are copied byte-for-byte. The tool cannot transcode, downscale, or re-compress — it only rewrites the container's metadata block. If you need to actually change the encode, that's a different video tool.
Separate DJI SRT / telemetry sidecar is not touched
Wrong toolSome drones save flight telemetry in a separate .SRT subtitle/log file alongside the video — that sidecar is a different file and is not part of the MP4 this tool scrubs. Delete the .SRT yourself before sharing; the scrubber only cleans the metadata inside the video container you drop in.
Title and chapters survive in default mode
By designMode: default deliberately keeps any human-set title and chapter markers because they're usually wanted navigation, not a privacy leak. If your montage's title or chapters name the location, switch to Mode: all, which adds -map_chapters -1.
File over your tier's size limit
rejectedThis tool requires Pro. Pro allows up to 10 GB per file and 5 files; Pro-media up to 100 GB and 50 files; Developer up to 100 GB and unlimited batch. A 4K/60 flight above your tier's ceiling is rejected before processing — upgrade or split the file. There's no Free-tier access.
Corrupt or truncated SD-card clip
errorIf FFmpeg cannot demux the input — a clip that didn't finish writing when the battery died, a truncated card transfer, or a renamed non-video — the run exits non-zero and the scrub fails with an error rather than producing a half-written file. Re-copy from the card or repair the source first.
Re-running 'all' mode is deterministic
ExpectedMode: all adds -fflags +bitexact, which suppresses FFmpeg's own version/encoder strings and timestamps. The practical effect: scrubbing the same clip twice produces byte-identical output, useful when you need a reproducible hash for an archive.
Container is preserved, not converted
By designThe output uses the same extension as the input — the tool never converts MOV to MP4. If a platform needs a different container, scrub the metadata first, then run a separate format conversion; combining the two would change the encode.
Embedded thumbnail / poster frame
RemovedA poster-frame image embedded as a metadata attachment is part of the metadata block and is dropped by -map_metadata -1. If you want to inspect what thumbnails a file hides before scrubbing, use hidden-thumbnail-extractor.
Frequently asked questions
Does this remove the GPS coordinates a drone embeds?
Yes. The GPS location tag DJI and other drones write into the container is a metadata tag, and -map_metadata -1 clears it along with every other tag. After scrubbing, the takeoff and flight coordinates cannot be read from the file's properties.
Will it hide my home point / takeoff location?
It removes the GPS coordinates stored in the file's metadata, which is what reveals the takeoff point in the file properties. If the takeoff spot is also visible in the footage itself, or written as on-screen HUD text, that's in the picture and a metadata stripper can't remove it — see the edge cases.
Is the footage re-encoded or compressed?
No. The command is -c copy, a stream-copy. The encoded H.264/H.265 picture and audio are copied straight through; only the container's metadata block is rewritten. There's no generational quality loss and no bitrate change — which is why it finishes in seconds even on 4K clips.
Does it remove the drone model and firmware version?
Yes. The model name and firmware/flight-controller strings are vendor custom tags in the metadata block, and -map_metadata -1 is a wholesale wipe — it doesn't pick a subset, so those go with everything else.
What does the DJI .SRT telemetry file have to do with this?
Nothing — that's a separate sidecar file, not metadata inside the video container. This tool only scrubs the video file you drop in. If you have an accompanying .SRT log, delete it yourself before sharing.
What's the difference between default and 'all' modes?
default runs -map_metadata -1 -c copy: it removes all GPS / model / firmware / date / encoder metadata but keeps the title and chapter markers. all adds -map_chapters -1 -fflags +bitexact: it also wipes chapters and the title and suppresses encoder identifier strings, producing a deterministic, fully anonymised file.
Does my footage get uploaded to a server?
No. FFmpeg runs as WebAssembly inside your browser tab. Your drone footage never leaves the machine, which matters because the raw file itself can encode your home location.
Can it scrub MKV proxies or WebM, or only MP4?
It accepts MP4, MOV, MKV, and WebM. The same engine clears Matroska and WebM tags (WRITING_APP, DATE_RECORDED, creation_time) exactly as it clears MP4-family atoms, and the output keeps the same container.
Can I clean a whole flight session at once?
Yes, in batch. Pro allows up to 5 files; Pro-media up to 50; Developer is unlimited. Each clip is scrubbed independently and each output keeps its own container and quality.
Will YouTube or Instagram open the cleaned file?
Yes. The container is valid and standard — only the metadata fields are emptied. Platform uploaders and editors open it normally, and the footage is bit-identical to the source.
How can I prove the scrub didn't alter the picture?
Run the source and the cleaned clip through file-integrity-monitor — it reports byte-equality and the first-difference offset, which lies inside the rewritten container header, confirming the media payload (mdat) is unchanged. Record a SHA-256 with multi-hash-fingerprinter for your archive.
What file sizes are allowed?
This tool requires Pro: up to 10 GB per file and 5 files. Pro-media allows up to 100 GB per file and 50 files; Developer allows up to 100 GB per file with unlimited batch. It's not available on the Free tier, and files above your ceiling are rejected before processing.
Privacy first
Every JAD Security operation runs entirely in your browser. Files, passwords, and PGP private keys never leave your device — verified by zero outbound network requests during processing.