exiv2.org

EXIF metadata is a structured block of information stored inside an image file that records how and when the photo was taken — camera model, exposure settings, timestamps, orientation, and often GPS coordinates. You can read it with a command-line tool or library, and you can edit or remove individual tags, but you should always work on a copy because writing metadata back into a file can fail or corrupt data depending on the format and the specific tags involved. This applies to JPEG, TIFF, and many RAW formats; the exact set of writable tags varies by file type.

Where EXIF Lives and What It Contains

EXIF is one metadata family among several. A single image commonly carries:

Exiv2, a cross-platform C++ library and command-line utility, reads and writes Exif, IPTC, and XMP metadata plus the ICC Profile embedded in digital images across various formats. It is free software and is used in projects including KDE and GNOME desktops, and in applications such as GIMP, darktable, shotwell, GwenView, and Luminance HDR.

The practical consequence: when you "edit EXIF," you are usually editing one block while the others stay untouched. A tool that only handles EXIF will not show you the IPTC caption or the XMP rating sitting in the same file.

Reading Metadata Before You Change Anything

Always inspect first. Reading tells you which tags exist, what values they hold, and whether the file even has the metadata you expect.

The general workflow:

1. Identify the file format — JPEG, TIFF, and RAW formats store metadata differently, and some tags are format-specific.
2. Dump all metadata with a command-line utility so you see EXIF, IPTC, and XMP together rather than one family at a time.
3. Note the exact tag names you intend to change. Tag naming differs between tools (for example, a human-readable name versus a numeric tag ID).
4. Check for a MakerNote — a vendor-specific block that many cameras write and that some tools cannot safely rewrite.

Expected result: a readable listing of tags and values. If a tag you expected is missing, the camera may not have written it, or the file may have been stripped by an earlier export or upload step.

Editing or Stripping Tags

Once you know what is there, editing is a matter of targeting specific tags and writing the file back.

• Change a value — set a single tag (for example, a copyright string or a timestamp) and save.
• Strip everything — remove all metadata, useful before publishing images that contain GPS coordinates or serial numbers.
• Strip selectively — remove only GPS or only MakerNote data while keeping exposure settings intact.

Two rules make this safe:

1. Keep a backup of the original. Metadata writing modifies the file in place in many workflows; if the write fails midway, the original is your only recovery path.
2. Verify after writing. Re-read the file with the same tool and confirm the tag now holds the value you set. A silent failure — where the command reports success but the tag is unchanged — is a real outcome on some formats.

Common Pitfalls

MakerNote quirks. MakerNotes are proprietary, undocumented blocks. Their internal layout can differ between camera models and even firmware versions. A tool may read a MakerNote correctly but refuse to write it, or write it in a way the camera's own software no longer recognizes. If preserving MakerNote data matters, test on a copy and confirm with a second tool.

Format-specific limits. Not every tag is writable in every container. Some formats support only a subset of EXIF fields, and some metadata families may not be writable at all in a given file type. The tool's documentation is the authority here, not assumptions carried over from JPEG.

Conflicting metadata. If EXIF and XMP both carry a timestamp or orientation value, different applications may prefer different sources. Editing one and not the other can produce inconsistent behavior across viewers.

Orientation tags. Changing an orientation tag without physically rotating pixels can make an image display differently in some viewers and correctly in others. Decide whether you are correcting the tag or the pixels — they are separate operations.

Choosing a Tool

For scripted or batch work, a command-line utility is the practical choice: it composes with shell loops, runs headless, and produces output you can diff. For application development, a library gives you programmatic read/write access to the same metadata families. Exiv2 covers both roles — a C++ library plus a command-line utility — which means the tag semantics you learn on the command line carry over to code that uses the library.

If you only need to read metadata occasionally, any viewer that displays EXIF will do. The moment you need to write, strip, or batch-process, move to a tool that documents which tags it can write for which formats.

MakerNote is a block of vendor-specific metadata that camera manufacturers embed inside the standard Exif structure. It is not part of the official Exif specification, so its layout, tag numbers, and meanings differ between brands (and often between camera models). You can read it with metadata tools such as Exiv2, which exposes MakerNote tags for many camera families, but editing it is only reliable where a tool has a documented mapping for that specific make and model — otherwise you risk corrupting the block or having it silently dropped.

Where MakerNote sits in the metadata stack

Standard Exif defines a fixed set of tags that any compliant reader understands: exposure time, ISO, aperture, focal length, orientation, timestamps, and so on. Camera vendors wanted to record far more than the standard allowed — lens IDs, autofocus points, face-detection data, picture styles, sensor temperature, shutter count, and proprietary shooting modes. Rather than extend the standard, they added a single private tag (Exif tag 0x927C, MakerNote) whose value is an opaque binary blob.

That design has two consequences:

• The blob is self-contained. A reader that doesn't understand a given vendor's format can still skip over it safely, because the outer Exif structure tells it how long the block is.
• The contents are not portable. Two cameras from different brands both have a MakerNote, but the bytes inside are unrelated. Even within one brand, the tag set can change between models or firmware versions.

This is why MakerNote is sometimes described as "Exif's escape hatch": it is standard Exif on the outside and proprietary data on the inside.

Why MakerNotes are hard to read and edit

The Exif specification does not require vendors to document their MakerNote layout. In practice, support comes from reverse engineering: comparing known camera outputs, correlating MakerNote bytes with settings changed on the camera, and cross-checking against vendor software.

The practical limits that follow:

Because of this, "read support" and "write support" are separate questions. A library may display hundreds of MakerNote tags for a camera yet only safely rewrite a subset.

Reading MakerNote with Exiv2

Exiv2 is a cross-platform C++ library and command-line utility that provides read and write access to Exif, IPTC, and XMP metadata and the ICC profile in images. Its command-line tool exiv2 is the quickest way to inspect MakerNote contents.

A typical inspection flow:

1. List all metadata, including MakerNote. Run exiv2 -pa image.jpg (print all) to see every tag the tool can decode, including MakerNote entries. Tags are shown with their family, tag name, and value.
2. Filter to MakerNote only. Use exiv2 -g MakerNote -pa image.jpg to narrow output to MakerNote-related tags, which is useful when a file has hundreds of entries.
3. Check what the tool actually recognizes. If a camera model is supported, you will see named tags with readable values. If it is not, you may see the raw Exif.MakerNote tag as an undecoded byte block, or only a partial set of tags.
4. Compare across files. Run the same command on a photo from a different camera to see how tag names and coverage change — this makes the per-model nature of MakerNote support concrete.

The expected result of step 1 is a long list; the expected result of step 2 is a short, camera-specific list. If step 2 returns almost nothing while step 1 shows a large MakerNote blob, that camera's format is not decoded by your build.

Preserving MakerNote when editing or converting

The most common real-world problem is not reading MakerNote — it is losing it. MakerNotes break or disappear when:

• An image is re-saved by software that only understands standard Exif and drops unknown tags.
• A conversion pipeline rebuilds the Exif block from scratch instead of copying it.
• Metadata is stripped for privacy or size, taking the MakerNote with it.
• The file is edited in a way that changes internal offsets the MakerNote depends on.

To keep MakerNote intact:

1. Copy rather than rebuild. Prefer tools that preserve the original Exif block and modify only the tags you target, instead of exporting to a new file and re-importing metadata.
2. Verify after every operation. Re-run exiv2 -g MakerNote -pa on the output and compare the tag count and values against the input. A drop in tag count is the signal that something was lost.
3. Test on a copy first. Because write support varies by camera, confirm that a round-trip (read, modify, write, re-read) leaves the MakerNote readable before applying it to originals.
4. Decide deliberately whether you need it. If you are publishing a photo and don't need lens IDs, AF points, or shutter count, stripping MakerNote is a legitimate choice — just make it a choice, not an accident.

Choosing an approach

• If you only need to view camera-specific settings: a metadata tool with broad MakerNote decoding (Exiv2 among them) is enough; no writing required.
• If you need to edit standard fields (date, copyright, keywords) while keeping MakerNote: use a tool that edits in place and preserves unknown tags, then verify.
• If you need to edit MakerNote values themselves: only do so for camera models your tool documents as writable, and always keep an untouched original.
• If you need guaranteed cross-tool behavior: treat MakerNote as read-only and rely on standard Exif, IPTC, and XMP for anything you must control.

XMP (Extensible Metadata Platform) is an XML-based metadata standard originally developed by Adobe that can be embedded in image files such as JPEG, TIFF, and PNG. You read or edit it with tools that understand the XMP packet structure — for example, the Exiv2 command-line utility or its C++ library, which provides read and write access to Exif, IPTC, and XMP metadata and the ICC Profile in a wide range of image formats. This article explains what XMP contains, how it differs from Exif and IPTC, and how to inspect and modify it.

What XMP actually stores

XMP is a structured, extensible format rather than a fixed field list. It is organized into namespaces, each covering a category of information:

Because XMP is XML, it can hold nested structures, arrays, and language alternatives that flat formats cannot express well. It is also designed to be extended — new namespaces can be added without breaking existing readers.

How XMP differs from Exif and IPTC

These three metadata families often coexist in the same file, but they serve different purposes:

• Exif — camera-generated capture data: exposure time, aperture, ISO, lens, orientation, GPS.
• IPTC — descriptive and rights information historically used in news and publishing workflows: captions, bylines, credit lines, copyright.
• XMP — a broader container that can carry descriptive, rights, editing, and workflow data, and can also mirror or replace legacy IPTC fields.

In practice, XMP is the most flexible of the three and is often where modern applications write their own information. A single image may carry all three, so an edit to one does not automatically update the others.

Reading XMP from an image

Using Exiv2 as an example, the general workflow is:

1. Identify the file and its metadata. Run a command that prints all metadata blocks so you can see whether an XMP packet exists and which namespaces are present. The expected result is a listing of Exif, IPTC, and XMP sections with their keys and values.
2. Filter to XMP only. Narrow the output to XMP keys so you can read specific fields such as title, creator, or rating without scrolling through Exif tags.
3. Check for conflicts. If the same information appears in both IPTC and XMP, note which one your downstream application reads before deciding what to change.

The exact command syntax depends on the Exiv2 version; consult the project's manual and examples for the current flags rather than relying on memorized options.

Editing XMP

Editing follows the inverse path:

1. Back up the original file before writing, since metadata edits modify the file in place.
2. Set the target field using the tool's write command, specifying the XMP namespace and property.
3. Verify the result by reading the file back and confirming the new value appears and that Exif and IPTC blocks are still intact.

A few practical cautions:

• Preserve existing Exif/IPTC data. Some operations can drop or overwrite blocks if not handled carefully. Always re-read the file after writing to confirm nothing was lost.
• Watch for duplicate representations. If your workflow reads IPTC but you only updated XMP, the change may not be visible where you expect it.
• Respect namespace prefixes. Writing to the wrong namespace (for example, a Photoshop field instead of Dublin Core) produces a valid file that your target application may ignore.

Choosing a tool

Exiv2 is a cross-platform C++ library and command-line utility that reads and writes Exif, IPTC, and XMP metadata plus the ICC Profile, and it is used in projects including KDE, GNOME, GIMP, darktable, shotwell, GwenView, and Luminance HDR. It is available as free software, with downloads and documentation on the project site. For scripted or batch metadata work it is a reasonable default; for interactive editing, a GUI application built on the same libraries may be more convenient.

Open source means the software's source code is publicly available, so anyone can inspect, modify, and redistribute it. Zen Cart, the platform running this reptile supply store, is open-source e-commerce software: the store owner can read and change the code, and no license fee is paid to a vendor. That matters to a small shop because it removes per-sale or monthly software fees and allows deep customization — but it also means the owner (or a developer they hire) handles hosting, updates, and security. Note that "open source" here describes the store software, not the reptile foods and supplements sold on it.

Open source in plain terms

Proprietary store platforms typically charge a subscription or a percentage of sales and keep their code closed. Open-source platforms publish the code under a license that permits use and modification. In practice, for a store like this one:

• No license fee. You pay for hosting and your own time, not for permission to run the software.
• Full access to the code. Layouts, checkout flow, and product pages can be changed beyond what a theme editor allows.
• Community development. Fixes and add-ons come from contributors and other store owners, not only from one company.

What it looks like on this store

The page evidence shows a typical Zen Cart storefront: category navigation (Bee Pollen, Cat Grass, Chia Seeds, Dandelion, Sprouting Seeds, Supplements), an "All Products" listing, reviews, and an information block with About Us, Shipping & Returns, Privacy Notice, Conditions of Use, Order Status, Site Map, Gift Certificate FAQ, and Discount Coupons. That structure — categories, reviews, coupons, gift certificates, order status — is what the platform provides out of the box. The store also publishes care guides (Russian Tortoise Care, Box Turtle Care, Redfoot Tortoise Care) and growing instructions, which are content pages the owner added rather than built-in store features.

Benefits for a small pet supply shop

• Cost control. No platform subscription means a low fixed cost that doesn't scale with order volume.
• Custom catalog logic. A shop selling seeds, dried weeds, and supplements by weight can adjust product options, units, and shipping rules directly in the code.
• Content and commerce in one place. Care guides and growing instructions sit alongside the catalog, which supports the store's stated role of helping customers find foods for herbivore reptiles.
• No vendor lock-in on data. You can export and migrate your catalog if you decide to move.

Trade-offs to plan for

Deciding whether it fits your store

Choose an open-source cart like Zen Cart if you want no license fees, need code-level customization, and have either technical skills or a developer you can call. Choose a hosted subscription platform instead if you'd rather not manage hosting, patches, and upgrades, and you're comfortable paying monthly for that convenience. A middle path works for many small shops: run the open-source cart on managed hosting that handles server updates, and keep a developer on retainer for store-level changes.

If you're evaluating this specific store as a model, the useful signal is that a niche reptile supply shop can run a full catalog, reviews, coupons, and care content on open-source software without a platform fee — the cost shifts from subscriptions to maintenance.

Image metadata is structured information embedded inside an image file rather than painted into its pixels. Exiv2, a cross-platform C++ library and command-line utility, reads and writes four common kinds: Exif, IPTC, XMP, and the ICC Profile. You can use it to inspect what a camera, editor, or scanner recorded, and to change those fields without re-encoding the image itself.

The four metadata types and what each one holds

They overlap in purpose but differ in origin, structure, and typical use.

Exif is what most people mean by "photo metadata" — it is written automatically when a picture is taken. IPTC and XMP are more editorial: they describe who made the image, what it shows, and how it may be used. The ICC Profile is different in kind: it does not describe the scene, it tells software how to interpret the colors so they display consistently across devices.

Because XMP is XML, it can hold custom schemas and is the most flexible of the four. IPTC predates it and uses a fixed field structure, which is why many tools now mirror IPTC values into XMP for compatibility.

How metadata is stored inside image files

Metadata is not a separate sidecar by default — it lives in defined segments or blocks within the file:

• JPEG: Exif sits in an APP1 segment; XMP also uses APP1; IPTC is carried in an APP13 (Photoshop) segment; the ICC Profile uses APP2.
• TIFF: Exif and IPTC are stored as tagged directories; XMP is embedded as a tag.
• PNG: metadata is held in named chunks (for example, text chunks for XMP and an iCCP chunk for the ICC Profile).

This matters because a tool must understand the container format, not just the metadata schema, to read or write correctly. Exiv2's stated scope is exactly this: read and write access to Exif, IPTC, XMP, and the ICC Profile embedded in images "in various formats."

Reading metadata with Exiv2

Exiv2 ships as both a library and a command-line utility. The command-line tool is the fastest way to see what is inside a file.

A typical read looks like this:

exiv2 image.jpg

Expected result: a printed list of metadata keys and values, grouped by family (Exif, IPTC, XMP). You use this to confirm what a file actually contains before editing — for example, to check whether GPS coordinates are present before publishing a photo.

To narrow the output, you can filter by metadata family or by a specific key. The exact option names are documented in the Exiv2 manual and API reference linked from the project site; check the version you have installed, since flags have changed across releases.

Editing metadata with Exiv2

Writing works by specifying a key and a new value, then saving:

exiv2 -M"set Exif.Image.Artist Jane Doe" image.jpg

Expected result: the Artist field is updated in the file. The same pattern applies to IPTC and XMP keys — you address the field by its family and name, and Exiv2 writes it back into the correct segment for that format.

Two practical points:

• Back up first. Metadata edits rewrite parts of the file. Keep an untouched copy so you can compare or revert.
• Verify after writing. Re-run the read command to confirm the value landed and that other fields were not disturbed.

For programmatic use, the C++ library exposes the same read/write model, which is why projects such as KDE, GNOME, GIMP, darktable, shotwell, GwenView, and Luminance HDR build on it.

Risks when modifying metadata

• Loss of MakerNote data. Camera-specific MakerNote fields are proprietary and can be dropped or corrupted by tools that do not handle them. Exiv2 explicitly lists MakerNote support, but not every editor does.
• Segment size limits. JPEG metadata segments have size ceilings; very large XMP blocks may not fit and can be truncated or rejected.
• Format mismatch. Writing an IPTC-only field into a format that does not carry IPTC segments will fail or be silently ignored.
• Color shifts. Replacing or removing an ICC Profile changes how the image is interpreted, even though the pixels are untouched.
• Privacy exposure. GPS, timestamps, and device serial numbers are easy to read — and easy to forget to strip before sharing.

Choosing a library or tool

Weigh these factors against your task:

• Coverage: does it handle all four types (Exif, IPTC, XMP, ICC), or only some?
• Read vs. write: many viewers read metadata; fewer write it safely.
• Format support: confirm it handles the containers you actually use (JPEG, TIFF, PNG, and others).
• MakerNote handling: important if you edit files straight from a camera.
• Licensing and integration: Exiv2 is described as free software with a C++ API, which suits embedding in an application; a standalone command-line tool suits one-off edits.
• Maintenance: check the current release and changelog before committing to it.

Exiv2 fits tasks that need both reading and writing across Exif, IPTC, XMP, and ICC in a range of formats, whether from the command line or from C++ code. For a single quick caption change, a GUI editor may be simpler; for batch or scripted metadata work, a library-backed CLI is the more controllable choice.