EXIF Remover — Strip Photo Metadata

Someone bought your old sofa through a classifieds app last spring. Payment went fine, pickup went fine, and then a second message arrived: nice house — the corner lot with the maple? You never mentioned a maple tree. You never mentioned an address. Your phone did, silently, in every photo you took for the listing, because the camera had location services enabled and wrote GPS coordinates into the file's metadata before it ever left your hands.

This is EXIF — Exchangeable Image File Format — the camera industry's filing system, bolted into the JPEG files that phones and cameras produce. Some of it is genuinely useful: exposure settings, lens data, the timestamp you will want someday when you are arguing about which year the beach trip happened. Some of it is a liability you have been shipping to strangers: latitude and longitude, altitude, the direction you were facing, the camera's serial number, sometimes your name.

Social networks mostly scrub this on upload. Email does not. Messaging apps that send photos as files do not. Cloud backup links do not. And the classifieds listing from our sofa story definitely did not, which is how a stranger ended up complimenting your landscaping. This tool exists for the gap between what platforms promise and what files actually contain: one click re-encodes the photo with nothing attached, and the whole question evaporates.

Below: how to use it, what EXIF actually is once you look inside the bytes, precisely what survives a proper strip, where metadata hides that people forget to check, and who needs this on a weekly basis. If you would rather see what a file is carrying before deciding, the companion EXIF Viewer prints the whole inventory.

A JPEG file is a sequence of chunks, each starting with a two-byte marker. The image data lives in one chunk; the metadata lives in others. The one that matters here is APP1 — marker bytes 0xFFE1 — which begins with the literal text 'Exif' followed by two zero bytes, and then, unexpectedly, a complete TIFF file. That embedded TIFF is the EXIF structure, and it is organized as a chain of image file directories, or IFDs.

Each IFD is a flat list of tagged entries, and every entry is exactly twelve bytes: two bytes of tag ID, two bytes of data type, four bytes of element count, four bytes that hold either the value itself or an offset pointing to it. Values longer than four bytes — GPS coordinates, camera names, timestamps as text — live elsewhere in the block, pointed at by those offsets. It is a tidy 1990s database design, chosen because it is cheap for a camera's firmware to write at the moment of capture.

The first directory, IFD0, holds the general tags: Make (0x010F), Model (0x0110), the orientation flag (0x0112), the change date (0x0132), and artist and copyright fields if anyone filled them in. It also holds two pointers of note — 0x8769, which leads to a sub-directory of shooting data, and 0x8825, which leads to the GPS block. Those pointers are why 'just delete the GPS tag' is harder than it sounds: the coordinates are not one tag but a constellation of them, scattered across a directory you reach by following a pointer from another directory.

The EXIF specification was born in the mid-1980s at Japan's electronics industry association — the organization now continued as the Camera and Imaging Products Association — which is why the standard's grammar of tags reads like firmware engineering rather than web design. Camera makers needed a way for photos to carry their own settings so labs could print them correctly and so warranty claims could be verified against shutter counts. Nobody imagined phones with GPS receivers, so when smartphones arrived and started writing the location block alongside the exposure data, the industry's tidy filing cabinet quietly turned into a tracking device.

That history explains the shape of the problem. EXIF was designed to be helpful first and invisible never — printers, cataloging software and forensic tools all depend on it, which is why your camera will never stop writing it. The burden of discretion falls on the person sharing the file, and that is exactly the burden this tool removes. Five minutes of understanding buys you a permanent habit: check what a photo carries, strip what you would not say out loud, then send.

The workflow is deliberately short — the tool's job is to be the fastest responsible decision you make before hitting send. Everything runs locally, so a 40-megapixel original processes in a few seconds without any upload progress bar to watch.

1. 1

   Drop your photos in

   Drag one file or fifty. The queue processes sequentially through the browser's File API, so memory stays predictable and nothing is held anywhere it should not be.

2. 2

   Glance at the metadata preview

   Before stripping, the tool shows the headline tags it found — camera, date, and a loud warning if GPS coordinates are present. Seeing the danger once is how the habit forms.

3. 3

   Choose the output format

   Clean JPEG is the default because it is universally viewable and the re-encode guarantees total removal. Pixel dimensions are preserved; quality is set high enough that the result is visually identical to the original.

4. 4

   Strip and download

   One click re-encodes each photo with metadata excluded from the write. The stripped copies download with their original filenames, so your folder structure survives the cleaning.

5. 5

   Verify when it matters

   For the paranoid and the professional, drag the output back into the EXIF Viewer and confirm the panel is empty. Two tools, ten seconds, certainty.

Knowing what is in the block makes the removal feel less like magic and more like a decision. These are the tags a modern phone typically writes, with the hexadecimal IDs the EXIF standard assigns them — the same IDs you would see scrolling past in ExifTool, the reference command-line tool for this domain.

Two details surprise people. First, exposure values are stored as rational numbers — f/2.8 is literally the fraction 28/10, a quarter-second is 1/4 — a 1998-era design that let integer-only camera firmware avoid floating-point math. Second, there is usually a second image inside the file: IFD1 holds a small JPEG thumbnail, written so file browsers can display previews without decoding the full image. It is a copy of the scene at lower resolution, and it goes too when the block is stripped.

The GPS directory deserves its own example, because its encoding is stranger than people expect. Coordinates are written as three rational numbers — degrees, minutes, seconds — with a separate one-letter reference saying north or south, east or west. A photo taken at 34 degrees 3 minutes 8.15 seconds north latitude stores 34/1, 3/1, 815/100 in the latitude tag and the ASCII letter N beside it. Translation software turns that into the decimal 34.0523, which any mapping site resolves to a street address. The information does not need to be readable by humans to be readable by machines — and machines are the ones you are hiding it from.

The removal strategy is almost embarrassingly simple once you see it. The browser decodes the file into raw pixels — the actual image, orientation applied, colors resolved. At that moment the metadata is already gone: it was never pixels, only annotations about them. The tool then encodes those pixels into a brand-new JPEG, and a canvas-encoded JPEG contains exactly one small header segment, the minimal JFIF marker, and nothing else. No APP1 block is created because there is nothing to put in one.

Compare that with the surgical approach, where software parses the metadata, removes selected tags, and rewrites the remaining structure with every offset recalculated. Surgical tools are wonderful for professionals who need to keep some tags and drop others, but they carry complexity risk — misaligned offsets can corrupt a file, and a partial strip can miss the GPS timestamp while deleting the coordinates, leaving location evidence in a field nobody remembers to check. The re-encode has no such failure mode. There is no menu of tags because no tag survives to be on the menu.

If you want the surgical experience anyway, the canonical tool is ExifTool on the command line, and its two most useful invocations are short enough to memorize: 'exiftool -all= photo.jpg' writes a copy with every tag removed, while 'exiftool -gps:all= photo.jpg' removes only the GPS directory, keeping camera data intact. The batch-flatten equivalent in your browser is this page; the verify step after either is the EXIF Viewer.

Two quiet side effects deserve a sentence each. The orientation flag disappears with everything else, which sounds alarming until you learn the browser applied it during decoding — the pixels come out upright, so the new file needs no flag. And any embedded ICC color profile goes too, which means a wide-gamut photo may shift a touch toward standard sRGB rendering. For sharing contexts that is usually an improvement; for proofing workflows, keep the original.

JPEG is not the only file walking around with annotations. XMP — Adobe's newer metadata format — rides in its own APP1 segment with a different signature, and can carry authorship, keywords and editing history. IPTC blocks, beloved by news agencies, travel in yet another segment. A partial cleaner that only parses the EXIF signature can leave both behind. The full re-encode does not care about signatures; anything that is not pixels simply has no way to cross the bridge.

• HEIC files from recent iPhones carry the same EXIF structure, GPS included — the format changed, the filing system came along
• PNGs, traditionally metadata-free, gained an eXIf chunk in the specification's third edition, so modern exports are no longer automatically clean
• Screenshots are usually born without camera metadata — the operating system took the picture, not a sensor
• Photo editors rewrite metadata on save, and some add their own — an edited photo can leak the editing software's name even when the camera's tags were removed
• Email attachments travel as original files, metadata intact — the classic vector for accidental location leaks
• Cloud sync keeps your pristine originals in the cloud even after you strip the copies you shared

Then there is the platform question. Instagram, Facebook and Twitter strip location metadata on upload as a matter of documented policy, and WhatsApp re-compresses images in a way that discards it. But classifieds sites, forums, file-sharing services and every app that sends photos as documents have no such uniform behavior. The professional habit is to treat platform stripping as a bonus and strip before sending, so the outcome never depends on somebody else's policy page.

Journalists and researchers top the list, because a photo with intact GPS can identify where it was taken, and sometimes who took it. The Committee to Protect Journalists has spent years telling reporters to scrub images from sensitive locations before publication, and newsroom workflows increasingly bake that step in before anything reaches a CMS.

The second group is ordinary people in exposed situations: sellers photographing belongings inside their homes, parents sharing photos of kids in school uniforms, renters documenting apartments, people leaving difficult relationships whose new address should not be derivable from a park selfie. The third group is conservationists — wildlife photographers learned the hard way that geotagged rhino and owl photos were being mined by poachers, and stripping location from rare-species shots is now standard practice in that community.

And a quieter professional crowd: drone operators sharing aerial shots near restricted sites, real-estate photographers whose camera serial numbers tie a listing to a contractor, and anyone whose camera body has been registered for warranty in their own name. Your threat model does not have to be dramatic for the metadata to be nobody's business.

You have options, and they are not equally blunt. The table below is the short version; the paragraphs after it are the honest one.

The desktop dialogs deserve their reputation for unreliability. Windows' 'Remove Properties and Personal Information' wizard removes a specific set of properties and leaves the rest of the structure in place; macOS Preview's export behavior varies by format and version. Neither shows you a complete before-and-after inventory the way a dedicated viewer does. When the stakes are real, verify — do not assume.

# The two ExifTool commands worth memorizing
exiftool -all= photo.jpg        # remove every metadata tag
exiftool -gps:all= photo.jpg    # remove only the GPS directory
exiftool -a -G1 -s photo.jpg    # inspect everything first, grouped by directory

There is a particular irony available online: metadata-removal sites that ask you to upload the very files you are trying to protect, so their servers can read them, strip them, and send them back. Whatever the policy says, the photos crossed the network, were held by a stranger's infrastructure, and now exist in a log somewhere, coordinates and all.

This page has no upload. The File API hands your photos directly to the browser's decoder, the re-encode happens in canvas memory on your machine, and the stripped copy is written by the same browser that read the original. No pixel or tag leaves the device, there is no server-side queue to sit in, and closing the tab ends the story. For files whose metadata is the sensitive part, the only safe architecture is the one with no architecture at all.

Strip, then verify, then share — in that order. The EXIF Viewer is the verification step, the JPG to PNG Converter and Image Compressor handle format and size once the file is clean, and the White Background Adder covers the e-commerce case where a marketplace-ready flatten also quietly removes every tag on the way through.