EXIF Data Explained: What's Hidden in Your Photos and How to Read It

Every photograph you take with a digital camera or smartphone contains more information than the pixels you can see. Embedded invisibly in the file is a structured block of metadata called EXIF data — the camera model that captured the image, every exposure setting used, the exact GPS coordinates where you stood, and the millisecond-precise timestamp of the shutter press.

This data travels with the image file wherever it goes. When you email a photo, post it on a forum, or submit it to a website, the EXIF data goes with it — unless you or the receiving platform explicitly removes it.

Inspect any photo's hidden metadata instantly with the ToolNest AI Image Metadata Viewer — 30+ fields, GPS to Maps link, JSON export, fully browser-side.

What Is EXIF Data?

EXIF stands for Exchangeable Image File Format. It is a standard for embedding metadata in image files, originally developed by the Japan Electronics and Information Technology Industries Association (JEITA) in 1995. The current version of the standard is EXIF 2.32.

EXIF data is not a separate file — it is embedded directly inside the image file itself, in a specific region at the beginning of a JPEG or TIFF file, or in the metadata chunk of a PNG, WebP, or HEIF file.

The metadata is organized into sections called Image File Directories (IFDs). Each IFD contains a list of tags — key-value pairs where the key is a 2-byte integer (the tag ID) and the value is typed data (integer, rational number, string, or binary blob).

EXIF File Structure

In a JPEG file, EXIF data lives in the APP1 marker segment — one of the optional application-specific blocks that can appear immediately after the Start of Image (SOI) marker:

FF D8          SOI — Start of Image
FF E1 XX XX   APP1 — Application segment 1 (EXIF)
  45 78 69 66 00 00   "Exif\0\0" header
  [TIFF byte order]
  [IFD0]
    → ExifIFD (EXIF sub-IFD)
    → GPS IFD (GPS sub-IFD)
    → MakerNote (vendor-specific)
FF E2          APP2 — ICC color profile
FF DB          DQT — Quantization tables
FF C0          SOF — Start of frame (image dimensions)
FF DA ... FF D9  Image data ... End of Image

The EXIF block can be up to 65,535 bytes (64KB) long. For images with many tags (especially MakerNote data from DSLRs), this can represent a significant fraction of the file size.

Camera and Device Fields

The first IFD (IFD0) contains basic information about the image and the device that captured it:

The Orientation tag is particularly important for web developers. Smartphones physically capture the image in portrait mode regardless of how the phone is held — the orientation tag tells the viewer how to rotate the display. If you read an image from an iPhone and ignore the orientation tag, landscape photos will appear sideways.

Exposure Settings

The EXIF IFD (sub-IFD pointed to by tag 0x8769) contains the photographic exposure parameters:

Aperture (F-stop) — stored as a rational number (numerator/denominator):

0x829D FNumber = 178/100 → f/1.78

Shutter speed — stored as a rational number representing seconds:

0x829A ExposureTime = 1/120 → 0.00833 seconds

ISO sensitivity:

0x8827 ISOSpeedRatings = 64

Focal length — the physical focal length of the lens in millimeters:

0x920A FocalLength = 6/1 → 6mm (physical)
0xA405 FocalLengthIn35mmFilm = 24 (equivalent)

The physical focal length (6mm on an iPhone camera) sounds very short, but the tiny image sensor makes a 6mm lens behave like a 24mm lens on a full-frame camera. The 35mm equivalent field is the more meaningful number for comparing field of view.

White Balance:

0xA403 WhiteBalance = 0 (Auto)

GPS Location Data

GPS data lives in its own sub-IFD referenced by tag 0x8825. The coordinates are stored as arrays of rational numbers in degrees, minutes, and seconds:

// Raw EXIF GPS storage
GPSLatitude = [48, 51, 3024/100]  // degrees, minutes, seconds
GPSLatitudeRef = "N"
GPSLongitude = [2, 17, 4020/100]
GPSLongitudeRef = "E"
 
// Conversion to decimal degrees
const lat = 48 + (51 / 60) + (30.24 / 3600);   // 48.8584
const lon = 2  + (17 / 60) + (40.20 / 3600);   // 2.2945

A coordinate pair like (48.8584, 2.2945) pinpoints a location to within 10–15 meters — more than precise enough to identify a building, a home, or a school.

The Privacy Implications

Most smartphone cameras embed GPS coordinates in every photo by default. This means every photo you share potentially reveals where it was taken. The consequences depend on the image:

• A photo taken at home reveals your home address
• A photo taken at a workplace reveals where you work
• A photo of a child at school reveals the school location
• A photo taken in an unfamiliar location while traveling reveals your itinerary

Many social media platforms (Instagram, Twitter/X) strip GPS data when you upload. Direct file transfers (email, messaging apps, file sharing) typically do not. If you share image files directly with any of these methods, the GPS data travels with them.

Reading EXIF Data in JavaScript

The browser's native APIs do not expose EXIF data directly — you must parse the binary JPEG file manually, or use a library. Here is how to locate the APP1 segment and read raw EXIF data using a DataView:

async function readExif(file) {
  const buffer = await file.arrayBuffer();
  const view = new DataView(buffer);
 
  // Check JPEG SOI marker
  if (view.getUint16(0) !== 0xFFD8) {
    throw new Error('Not a JPEG file');
  }
 
  let offset = 2;
  while (offset < view.byteLength) {
    const marker = view.getUint16(offset);
    const segmentLength = view.getUint16(offset + 2);
 
    if (marker === 0xFFE1) {
      // APP1 — check for "Exif" header
      const exifHeader = String.fromCharCode(
        view.getUint8(offset + 4),
        view.getUint8(offset + 5),
        view.getUint8(offset + 6),
        view.getUint8(offset + 7)
      );
      if (exifHeader === 'Exif') {
        return parseExifIFD(view, offset + 10, view.byteLength);
      }
    }
 
    offset += 2 + segmentLength;
    if (marker === 0xFFDA) break; // SOS (start of scan) — stop here
  }
 
  return null;
}
 
function parseExifIFD(view, tiffStart, fileEnd) {
  // Read byte order (0x4949 = little-endian, 0x4D4D = big-endian)
  const byteOrder = view.getUint16(tiffStart);
  const isLittleEndian = byteOrder === 0x4949;
 
  const readUint16 = (offset) =>
    view.getUint16(tiffStart + offset, isLittleEndian);
  const readUint32 = (offset) =>
    view.getUint32(tiffStart + offset, isLittleEndian);
 
  const ifdOffset = readUint32(4);
  const tagCount = readUint16(ifdOffset);
 
  const tags = {};
  for (let i = 0; i < tagCount; i++) {
    const tagOffset = ifdOffset + 2 + i * 12;
    const tagId = readUint16(tagOffset);
    const type  = readUint16(tagOffset + 2);
    const count = readUint32(tagOffset + 4);
    // value or offset at tagOffset + 8
    tags[tagId] = { type, count, valueOffset: tagOffset + 8 };
  }
 
  return tags;
}

For production use, the exif-js or exifr npm packages handle all edge cases (MakerNote blobs, GPS rational parsing, undefined values, big-endian/little-endian, etc.).

Reading EXIF Data in Python

Pillow provides simple access to EXIF data via ._getexif() (deprecated) or the newer getexif() method:

from PIL import Image
from PIL.ExifTags import TAGS, GPSTAGS
 
def read_exif(path):
    img = Image.open(path)
    exif_data = img.getexif()
    
    result = {}
    for tag_id, value in exif_data.items():
        tag_name = TAGS.get(tag_id, tag_id)
        
        # Decode GPS sub-IFD
        if tag_name == "GPSInfo":
            gps = {}
            for gps_id, gps_val in value.items():
                gps[GPSTAGS.get(gps_id, gps_id)] = gps_val
            result["GPS"] = gps
        else:
            result[tag_name] = value
    
    return result
 
def gps_to_decimal(dms, ref):
    degrees, minutes, seconds = dms
    decimal = float(degrees) + float(minutes) / 60 + float(seconds) / 3600
    if ref in ["S", "W"]:
        decimal = -decimal
    return decimal
 
data = read_exif("photo.jpg")
if "GPS" in data:
    lat = gps_to_decimal(data["GPS"]["GPSLatitude"], data["GPS"]["GPSLatitudeRef"])
    lon = gps_to_decimal(data["GPS"]["GPSLongitude"], data["GPS"]["GPSLongitudeRef"])
    print(f"Location: {lat:.6f}, {lon:.6f}")
    print(f"Maps: https://maps.google.com/?q={lat},{lon}")

MakerNote: Vendor-Specific Data

The MakerNote (tag 0x927C) is a vendor-specific binary blob embedded by the camera manufacturer. Canon, Nikon, Apple, Sony, and others store additional data here that is not part of the standard EXIF specification:

• Apple MakerNote: image quality setting, burst count, live photo flag, person detected
• Canon MakerNote: color matrix, picture style, noise reduction settings
• Nikon MakerNote: lens type (AF-S, AF-D, etc.), vibration reduction mode
• Sony MakerNote: picture profile, SteadyShot status

The MakerNote format is not publicly documented by most manufacturers, and its structure varies by camera model and firmware version. Parsing it reliably requires reverse-engineered format tables maintained by the ExifTool project.

Which File Formats Support EXIF?

Frequently Asked Questions

What information does EXIF data contain?

EXIF data typically includes camera make and model, lens specifications, exposure settings (aperture, shutter speed, ISO), white balance, focal length, image dimensions, color space, creation date and time, orientation, GPS coordinates (if location was enabled), and photographer/copyright information.

Does every photo have EXIF data?

No. EXIF data is added by the camera or device that captured the image. Screenshots, images downloaded from the web, or images processed by tools that strip metadata will have no EXIF data. Professionally edited images processed through Lightroom may have reduced EXIF (the original camera data is often preserved, but processing tags vary).

Does sharing a photo on social media expose my GPS data?

It depends on the platform. Instagram, Twitter/X, and Facebook strip EXIF data (including GPS) when you upload. Many other platforms — direct messaging apps, file sharing services, forums — do not strip EXIF. When you share a file directly (email, WhatsApp, AirDrop, WeTransfer), the EXIF data travels with it intact.

How do I remove GPS from a photo before sharing?

You can use the ToolNest AI Remove Image Metadata tool to strip all EXIF data from any image in your browser — no upload required. You can also disable location recording in your phone's camera settings: on iOS, go to Settings → Privacy → Location Services → Camera and set it to "Never." On Android, open Camera settings and disable the location tag option.

Can EXIF data be faked or manipulated?

Yes. EXIF data is plain data stored in the file — it has no cryptographic signature and can be modified with tools like ExifTool. Date stamps can be altered, GPS coordinates can be changed, and camera model fields can be edited. EXIF data alone is not reliable as forensic evidence of when or where an image was taken.

What is the MakerNote in EXIF data?

The MakerNote is a vendor-specific extension to EXIF — a blob of binary data where camera manufacturers store settings and features not covered by the standard EXIF tags. Apple uses it to store live photo flags and focus point data; Canon uses it for picture style settings; Nikon for lens type codes. The format is reverse-engineered and vendor documentation is rarely public.

How accurate is GPS in EXIF data?

Consumer smartphone GPS typically achieves 3–5 meter accuracy outdoors with a clear sky view. In urban canyons or indoors, accuracy may degrade to 10–50 meters. The EXIF GPS timestamp (GPSTimeStamp) is in UTC and is derived from the GPS signal, making it more reliable than the device clock.

What is the difference between the camera date and the file modification date?

The EXIF DateTimeOriginal (tag 0x9003) is the date and time the shutter was pressed, stored by the camera. The file's modification date (visible in your file system) is set by the operating system and changes when the file is moved, copied, or edited. The EXIF date is more reliable for determining when a photo was actually taken.