# EXIF Viewer

> Free online EXIF viewer: read every metadata tag in a photo — camera, lens, exposure, software and GPS coordinates. No upload, no map embed, nothing tracked.

- URL: https://bytescope.dev/en/exif-viewer/
- Locale: en · Also: [ja](https://bytescope.dev/ja/exif-viewer.md) · [zh-Hant](https://bytescope.dev/zh-Hant/exif-viewer.md)
- Runs: Your files never leave your browser — all processing is local.
- Requires: Any modern browser (Chrome, Edge, Firefox, Safari), desktop and mobile.
- Updated: 2026-09-08

## What it does

Every JPEG a camera or phone writes carries a block of EXIF metadata, and this page lays all of it out instead of the four fields most viewers bother with. The first group is the gear: `Make` and `Model` for the body, `LensModel` for the glass in front of it, and the firmware or app version in between. That is usually enough to answer the questions people actually have about a file someone sent them — which of my two bodies shot this, was this the 35mm or the kit zoom, was this frame really taken on the camera the listing claims it was.

The second group is the exposure triangle, and it is why most photographers open a tag viewer at all: `ExposureTime`, `FNumber` and `ISO` next to each other, with `FocalLength` and `DateTimeOriginal` beside them. Reading `1/200 s`, `f/2.8` and `ISO 1600` together tells you why a shot is noisy or why one frame in a burst went soft, and the original capture time is the one date that survives copying, re-saving and every file timestamp that got rewritten on the way.

The third group is the quiet one. The `Software` and processing fields record what last wrote the file, so a photo can announce that it went through Lightroom, a phone's beauty mode, a screenshot tool or an AI upscaler long after anyone would have mentioned it. Editors often leave an embedded thumbnail behind too, and a stale thumbnail sometimes still shows the frame as it was before a crop. None of this is secret exactly — it is just information you did not know you were shipping, which is a good reason to look before you publish.

The last group is location, and it is handled deliberately. When a GPS IFD is present you get latitude and longitude in decimal degrees with one-click copy, the hemisphere references, and altitude if the camera recorded it — and no embedded map. Dropping in a third-party map frame would mean sending your photo's coordinates to someone else's tile server the moment the page rendered, which on a page about location privacy would be self-defeating. If you want to see the spot, paste the copied coordinates into whatever map you already trust: that request is then yours, made knowingly, while the photo itself never leaves your browser.

## Limits

Does not edit or remove metadata (use remove-exif) and does not read metadata from PDFs or videos.

## Machine output

Copy JSON copies an envelope `{ tool, url, generatedAt, userAgentHint, result }`. `tool` is `"exif-viewer"`; `result` is the on-screen EXIF snapshot below. This JSON includes precise GPS coordinates (signed decimal degrees and altitude in metres) when the photo's GPS IFD decoded them — that is an exact location. The file name, thumbnail bytes, and any base64 blob are omitted.

- `mime` (string | null) — Sniffed image MIME. `null` = sniff did not name a type.
- `byteLength` (number | null) — File size in bytes. `null` = size was not supplied.
- `make` (string | null) — Camera make. `null` = tag absent or EXIF not parsed.
- `model` (string | null) — Camera model. `null` = tag absent or EXIF not parsed.
- `lensModel` (string | null) — Lens model. `null` = tag absent or EXIF not parsed.
- `software` (string | null) — Software tag. `null` = tag absent or EXIF not parsed.
- `orientation` (number | null) — EXIF orientation 1–8. `null` = tag absent or EXIF not parsed.
- `dateTimeOriginal` (string | null) — Raw `"YYYY:MM:DD HH:MM:SS"`. `null` = tag absent or EXIF not parsed.
- `exposureTime` (string | null) — Formatted exposure (e.g. `"1/200 s"`). `null` = tag absent or EXIF not parsed.
- `fNumber` (string | null) — Formatted aperture (e.g. `"f/2.8"`). `null` = tag absent or EXIF not parsed.
- `iso` (number | null) — ISO speed. `null` = tag absent or EXIF not parsed.
- `focalLength` (string | null) — Formatted focal length (e.g. `"26 mm"`). `null` = tag absent or EXIF not parsed.
- `hasIccProfile` (boolean | null) — `null` = no EXIF block parsed; `false` = parsed, no ICC; `true` = ICC present.
- `gps` (object | null) — `null` = no GPS IFD (no GPS tags). When present: `latitude`, `longitude` (signed decimal degrees), `altitude` (metres). Each is `null` when that GPS tag was present but did not decode.
- `tags` (array of objects) — Raw tags in on-screen order, capped at 200. Each item: `ifd` (`"IFD0"` | `"Exif"` | `"GPS"`), `id` (number), `name`, `value`.
- `truncated` (boolean) — `true` when more tags exist than were copied.
- `totalCount` (number) — Real tag count, not the copied length.

## FAQ

### Why does my photo have no EXIF at all?

Because something already stripped it. Messaging apps and social platforms recompress what you upload and drop the metadata as part of that, so a photo that arrived through WhatsApp, Messenger or Instagram is usually already clean. Screenshots never had EXIF in the first place — the system drew those pixels, so there is no camera, lens or exposure to describe — and the same is true of most exports from drawing and design tools. Scans are a third case: a scanner may write only a timestamp and its own `Software` string. An empty tag table is nearly always a fact about the file's history, not a failure of the reader.

### What can the software and processing fields give away?

More than people expect. `Software` names whatever last saved the file, which is how a photo ends up telling you it passed through Lightroom, a phone's portrait or beauty mode, a screenshot utility, or an upscaler. Related fields can record that a scene mode fired, that HDR merged several frames, or that the image was rotated or resized after capture. Put next to the camera fields, that answers a question no single tag does: has this file been through an editor since it left the sensor, and does the story the sender told match the story the file tells.

### Is my photo uploaded to read its EXIF?

No. The file is read with the File API and parsed by JavaScript running in your own tab: the page walks the JPEG marker segments, finds the EXIF block and decodes the tags on your machine. There is no server behind this page to send anything to, and once loaded it works with the network off. That matters more here than on a typical converter, because the tags you most want to inspect — GPS coordinates, capture times, a camera serial number — are exactly the ones you would least want to hand to a stranger's server first.

### Why does my photo have GPS coordinates when location is off?

Location permission is per-app, not global, so the camera app can be tagging photos while other apps are getting nothing. Most phone cameras also have their own separate 'location tags' switch buried in their settings, which stays on even after you deny location to everything else. Two more sources catch people out: EXIF is copied when a file is re-saved or shared, so a photo you edited last week keeps the coordinates it was born with, and a photo received from someone else carries theirs. The only reliable answer is to check the file itself, which is what this page is for.

### Which file formats can I inspect?

EXIF in practice means JPEG and TIFF-headered files, and those are what this viewer reads — `.jpg`/`.jpeg` straight off a camera or phone, plus TIFF-container files including many camera RAW formats. PNG and WebP can carry metadata in their own containers but usually carry very little, and screenshots carry none at all, so expect a short table or an empty one. HEIC from an iPhone does hold EXIF, but inside a HEIF container that browsers cannot open without a decoder — convert it to JPEG first and the tags come along.

## Related tools

- [Remove EXIF](https://bytescope.dev/en/remove-exif.md) — Strip this photo's metadata losslessly — pixels are never re-encoded.
- [Binary Diff](https://bytescope.dev/en/binary-diff.md) — Compare two files byte by byte, e.g. before and after stripping.