Free · runs in your browser
The commands worth remembering, what each line of output means, and how to strip tags with ffmpeg without re-encoding.
To see a video’s metadata with ffprobe, run ffprobe -hide_banner video.mp4 for a readable summary, or ffprobe -v error -show_format -show_streams -of json video.mp4 for every field as JSON. ffprobe ships with FFmpeg, runs on Windows, macOS and Linux, and only reads files; to change or remove metadata you use ffmpeg itself.
This guide gives the commands that answer the questions people actually ask (which codec, which frame rate, is it HDR, is it rotated, where was it filmed) and explains the output line by line. Every option below was checked against the current FFmpeg documentation.
If you can’t install anything, or you want the same facts with explanations and a map, the browser video file info report reads the file on your device and offers JSON as well. Both approaches are covered at the end.
You need FFmpeg installed; ffprobe comes with it. Then open a terminal in the folder that holds the video.
Download a build from the links on ffmpeg.org, or use a package manager: brew install ffmpeg on a Mac with Homebrew, sudo apt install ffmpeg on Debian or Ubuntu. Check it works with ffprobe -version.
Run ffprobe -hide_banner clip.mov. -hide_banner skips the copyright and build options, leaving the container, duration, overall bitrate, tags and one line per stream.
Run ffprobe -v error -show_format -show_streams -of json clip.mov. -v error silences the log, -show_format prints the container section, -show_streams prints one section per stream, and -of json chooses the output writer.
Use -select_streams v:0 for the first video stream and -show_entries to list fields, for example -show_entries stream=codec_name,width,height,avg_frame_rate.
Run ffmpeg -i clip.mov -map 0:v -map 0:a? -map_metadata -1 -map_chapters -1 -c copy clean.mov. The streams are copied, not re-encoded, and the global and per-stream tags are not carried over.
Here is a shortened summary for a phone clip. The layout varies a little between FFmpeg versions, but the pieces are always in this order: the container, its tags, the duration line, then one line per stream with that stream’s own tags and side data underneath.
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from "clip.mov":
Metadata:
major_brand : qt
creation_time : 2026-03-03T18:42:10.000000Z
com.apple.quicktime.make: Apple
com.apple.quicktime.model: iPhone 16 Pro
com.apple.quicktime.software: 26.3
com.apple.quicktime.location.ISO6709: +51.4769-000.0005+046.000/
Duration: 00:00:12.48, start: 0.000000, bitrate: 50614 kb/s
Stream #0:0[0x1]: Video: hevc (Main 10) (hvc1 / 0x31637668), yuv420p10le(tv, bt2020nc/bt2020/arib-std-b67), 3840x2160, 50112 kb/s, 59.94 fps, 59.94 tbr, 600 tbn (default)
Side data:
DOVI configuration record: version: 1.0, profile: 8, level: 9, ...
Stream #0:1[0x2]: Audio: aac (LC) (mp4a / 0x6134706D), 48000 Hz, stereo, fltp, 191 kb/s (default)
| Piece | What it tells you |
|---|---|
mov,mp4,m4a,3gp,3g2,mj2 | The demuxer that opened the file. MP4 and MOV share one, so this does not tell you which of the two it is; major_brand does (qt is QuickTime MOV, isom or mp42 is MP4). |
creation_time | The date in the movie header, always in UTC. Apple’s creationdate key next to it keeps the local time zone. |
com.apple.quicktime.* | Apple’s metadata keys: make, model, iOS version and the location as an ISO 6709 string (latitude, longitude, altitude). |
Duration … bitrate | Length of the file and the overall bitrate of everything in it, audio included. |
hevc (Main 10) (hvc1 / …) | Codec, profile and the codec tag. hvc1 plays on Apple devices; hev1 often does not. |
yuv420p10le(tv, bt2020nc/bt2020/arib-std-b67) | Pixel format (10-bit 4:2:0), range (tv is limited), then matrix, primaries and transfer. arib-std-b67 is HLG; smpte2084 is PQ, used by HDR10 and Dolby Vision. |
59.94 fps, 59.94 tbr, 600 tbn | Average frame rate, the guessed base rate, and the time base the timestamps count in. |
DOVI configuration record | Dolby Vision is present; profile 8 is the kind phones record, with a base layer other players can show. |
ffprobe -v error -select_streams v:0 -show_entries "stream=codec_name,profile,width,height,pix_fmt,r_frame_rate,avg_frame_rate" -of json clip.mov
r_frame_rate is the lowest rate that can represent every timestamp, while avg_frame_rate is frames divided by duration. On a constant-rate file they match. When they differ, as they often do on phone footage, the file is probably variable frame rate; the frame rate checker measures the real spread.
ffprobe -v error -show_entries format=duration -of default=nokey=1:noprint_wrappers=1 clip.mov
nokey=1 drops the field name and noprint_wrappers=1 drops the section header and footer, so the output is a single value you can use in a script.
ffprobe -v error -show_entries "format_tags:stream_tags" -of json clip.mov
This is the quickest privacy check. Look for location, location-eng or com.apple.quicktime.location.ISO6709 (where it was filmed), make and model keys, encoder (the app that wrote the file) and creation_time. MKV files keep their tags here too, including per-track DURATION and title.
ffprobe -v error -select_streams v:0 -show_streams -of json clip.mov
In the stream’s side_data_list, an entry with "side_data_type": "Display Matrix" carries a rotation value such as -90: the picture is stored landscape and players turn it. An entry of type DOVI configuration record carries dv_profile and dv_level. HDR10 files may also carry Mastering display metadata and Content light level metadata entries; the HDR checker explains what those numbers mean.
ffprobe -v error -select_streams v:0 -count_packets -show_entries stream=nb_read_packets -of csv=p=0 clip.mov
ffprobe -v error -select_streams v:0 -count_frames -show_entries stream=nb_read_frames -of csv=p=0 clip.mov
-count_packets reads the file without decoding and is fast. -count_frames decodes every frame, which is exact but slow on a long 4K file. For video the two numbers are normally the same. csv=p=0 prints the bare value without the section name.
ffprobe -v error -select_streams v:0 -read_intervals %+5 -show_entries packet=pts_time,duration_time -of csv=p=0 clip.mov
-read_intervals %+5 reads only from the start to five seconds in. Uneven gaps between the pts_time values are what variable frame rate looks like in raw form.
ffprobe -v error -show_chapters -of json clip.mp4
ffprobe never writes to a file. To remove tags you remux with ffmpeg, copying the streams into a new container and telling it not to bring the metadata along:
ffmpeg -i clip.mov -map 0:v -map 0:a? -map_metadata -1 -map_chapters -1 -c copy -fflags +bitexact clean.mov
| Option | What it does |
|---|---|
-map 0:v -map 0:a? | Keeps the video and audio streams only. The ? makes the audio map optional, so a silent clip does not fail. Data tracks such as GPS telemetry and timecode are left behind. |
-map_metadata -1 | A negative file index disables the automatic copying of global and per-stream metadata. |
-map_chapters -1 | Does the same for chapters, whose titles can contain names or places. |
-c copy | Copies the compressed streams as they are. No re-encode, no quality loss, and it runs at disk speed. |
-fflags +bitexact | Asks the muxer to write only build- and time-independent data, which keeps it from stamping its own version string into the file. |
Always inspect the result. What survives a remux depends on the container and the FFmpeg version: the muxer writes its own default handler names, and the rotation flag is kept because it is side data, which is usually what you want. Run the tags command above on the new file, or open it with the browser report, before you share it.
ffmpeg -i clip.mp4 -map 0:v -map 0:a? -c copy -metadata title="Harbour at dusk" -metadata:s:a:0 language=eng tagged.mp4
-metadata key=value sets a global tag and -metadata:s:a:0 targets the first audio stream. An empty value deletes a tag. MP4 only stores keys it has a box for unless you add -movflags use_metadata_tags, which writes arbitrary keys in the mdta style Apple uses. For everyday edits with field names you can read, the video metadata editor does the same lossless rewrite in the browser.
| You want to… | Better tool |
|---|---|
| Check hundreds of files in a script or CI job | ffprobe, with -of json and a shell loop |
| Dump every packet or frame with timestamps | ffprobe (-show_packets, -show_frames) |
| Understand one file, with each value explained | The browser report |
| See where a clip was filmed on a map | The browser location view |
| Inspect a file on a phone or a locked work PC | The browser report; nothing to install |
| Strip or edit tags without re-encoding | Either: ffmpeg -c copy, or Remove all metadata here |
In the browser, open the file, go to Report and you get a MediaInfo text report, JSON and an MP4/MOV box tree, with Download JSON for scripts. The remove metadata page covers the browser equivalent of the ffmpeg strip, including exactly which fields it clears and how What changed confirms the result.
for f in *.mp4; do
ffprobe -v error -select_streams v:0 -show_entries stream=codec_name,width,height,avg_frame_rate -of csv=p=0 "$f"
done
In bash or zsh this prints one line of codec, width, height and frame rate per file. In PowerShell a similar loop that prints each duration is Get-ChildItem *.mp4 | ForEach-Object { ffprobe -v error -show_entries format=duration -of csv=p=0 $_.FullName }.
ffmpeg -i file prints a similar summary but then stops with “At least one output file must be specified”, because ffmpeg expects to convert something. ffprobe is built to inspect: it has machine-readable writers (JSON, XML, CSV) and options such as -show_entries and -count_frames.
Some containers do not store those values per stream. Matroska (MKV, WebM) keeps the duration at file level and often in a DURATION tag, and many files leave stream bitrates out. Use -show_format for the file-level figures, or -count_packets for an exact count.
It is stored in UTC. A clip recorded at 19:42 in summer in London shows 18:42Z. Apple’s com.apple.quicktime.creationdate keeps the local offset; files that went through a messaging app may have a new date or none at all.
No, it only reads. Use ffmpeg with -map_metadata -1 -c copy to strip, or -metadata key=value to set a tag, writing to a new file.
It stops ffmpeg copying the tags, but you still need -map_chapters -1 for chapters and careful -map choices to leave data tracks behind. The muxer may write a few defaults of its own, so check the output.
With -count_frames it decodes every frame, so yes, but it is slow. nb_frames from -show_streams is read from the container and is usually right for MP4, but can be missing for MKV or broken files.
Not without a terminal app and a self-built FFmpeg. On a phone, open the file in the browser and go to Report for the same kind of information.