# Image Metadata Analyzer & Privacy Stripper (`perryay/image-metadata-analyzer`) Actor Extract EXIF (GPS, camera, exposure), IPTC (copyright, keywords), XMP (rights, creator) metadata from images. Privacy mode strips all metadata and returns clean base64 image bytes. GPS to human-readable address via reverse geocoding. Supports JPEG, PNG, TIFF, WebP, HEIC/HEIF. - **URL**: https://apify.com/perryay/image-metadata-analyzer.md - **Developed by:** [Perry AY](https://apify.com/perryay) (community) - **Categories:** Developer tools - **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.02 / actor start This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Image Metadata Analyzer & Privacy Stripper — Extract or Remove Hidden Photo Data **Pull every piece of hidden data out of your images — or strip it all away before you share them.** Drop in a JPEG from your phone and you'll see which camera took it, the exact GPS coordinates where you stood, the exposure settings the camera chose, and any copyright notices or captions embedded in the file. Switch to privacy mode and the same image comes back with every trace of metadata surgically removed. This actor reads EXIF (camera, GPS, exposure), IPTC (copyright, keywords, captions), and XMP (creator, rights, ratings) from JPEG, PNG, TIFF, WebP, and HEIC/HEIF images. No external libraries — just pure Python byte-level parsing. --- ### What does it do? Every photo you take carries a hidden payload. The phone model, the GPS fix accurate to within metres, the exact timestamp, the lens and aperture settings, and any edit history from software you've opened it in. This data is invisible when you look at the image, but anyone who downloads your file can extract it in seconds. This actor reads all three major metadata formats: - **EXIF** — GPS latitude and longitude, camera make and model, date taken, exposure time, aperture, ISO, focal length, flash status, and orientation - **IPTC** — Copyright notice, keywords, captions, byline, and headline from Photoshop and similar editors - **XMP** — Creator attribution, usage rights, star ratings, and Dublin Core metadata from Adobe and other modern tools GPS coordinates can optionally be reverse-geocoded through OpenStreetMap Nominatim to a human-readable address — "123 High Street, Bristol, UK" instead of "51.4545, -2.5879". For privacy, the actor strips metadata from each format individually. JPEG stripping preserves the orientation tag so your photo doesn't rotate sideways. PNG stripping removes tEXt/iTXt/zTXt chunks. WebP stripping removes EXIF/XMP chunks. HEIC stripping attempts to remove the metadata track from the MOOV box. TIFF stripping is best-effort due to the format's variability. Three modes: - **Extract** — Pull everything: EXIF, IPTC, XMP, GPS address, dimensions, file size, and colour mode - **Strip** — Wipe all metadata markers and return a clean base64-encoded version - **Both** — Extract the metadata first, then strip and return the clean version alongside it --- ### Features 1. **EXIF extraction** — GPS coordinates (latitude, longitude, altitude), camera make and model, date and time taken, exposure time, F-number, ISO speed, focal length, flash status, and image orientation 2. **GPS reverse geocoding** — Optional Nominatim lookup converts raw coordinates into a street-level address 3. **IPTC extraction** — Copyright notice, keywords, caption/description, byline, headline, and category/supplemental category fields 4. **XMP extraction** — Creator attribution, usage rights, star rating, and Dublin Core metadata (title, description, date) 5. **Format-aware stripping** — Separate strip logic per format: JPEG (orientation preservation), PNG (text chunk removal), WebP (EXIF/XMP chunk removal), HEIC (MOOV metadata track removal), TIFF (best-effort) 6. **Format detection** — Magic-byte detection for all five supported formats 7. **Dimension extraction without decoding** — Reads width and height directly from binary headers for JPEG (SOF marker), PNG (IHDR chunk), WebP (VP8/VP8L/VP8X), TIFF (ImageWidth/ImageLength tags), HEIC (ISO BMFF header) 8. **Batch processing** — Up to 50 images per run, 5 concurrent downloads via asyncio semaphore 9. **Per-image isolation** — One image failing to download or parse doesn't affect the rest of the batch --- ### Who is it for? | Persona | What they use it for | |---------|---------------------| | **Photographer** | Checking EXIF data on client work to confirm camera settings and shooting conditions | | **Security researcher** | Auditing images shared online for leaked GPS coordinates and device serial numbers | | **Developer** | Integrating metadata extraction into content pipelines, CMS uploads, or image processing workflows | | **Privacy-conscious user** | Stripping location and camera data before sharing photos on social media or forums | | **Digital asset manager** | Indexing image libraries by copyright, keywords, and creation date from IPTC and XMP fields | | **Journalist** | Verifying the provenance of images — camera, date, software edit history — before publication | --- ### Input Parameters | Field | Type | Required | Default | Description | |-------|------|----------|---------|-------------| | `images` | array | Yes | — | List of image URLs or data URIs to process. Max 50. | | `mode` | enum | No | `extract` | `extract`, `strip`, or `both` | | `include_gps` | boolean | No | `true` | Reverse-geocode GPS coordinates to a street address via Nominatim | | `strip_preserve_orientation` | boolean | No | `true` | When stripping, keep the orientation tag so the image doesn't rotate | --- ### Example Input #### Extract all metadata from an image ```json { "images": ["https://example.com/photos/vacation.jpg"], "mode": "extract", "include_gps": true } ```` #### Strip metadata for privacy ```json { "images": ["https://example.com/photos/selfie.jpg", "https://example.com/screenshots/dashboard.png"], "mode": "strip", "strip_preserve_orientation": true } ``` #### Extract then strip (full transparency + clean file) ```json { "images": ["https://example.com/uploads/portrait.heic"], "mode": "both", "include_gps": false } ``` *** ### Output Format Each item in the dataset corresponds to one input image. | Field | Type | Description | |-------|------|-------------| | `filename` | string | Filename extracted from the URL or `inline.` for data URIs | | `format` | string | Detected format: JPEG, PNG, TIFF, WebP, HEIC | | `width` | integer / null | Width in pixels | | `height` | integer / null | Height in pixels | | `file_size_bytes` | integer | Size of the downloaded image in bytes | | `color_mode` | string / null | Detected colour mode (RGB, RGBA, Grayscale, CMYK, Lab, or unknown) | | `exif` | object / null | EXIF data: camera\_make, camera\_model, date\_taken, exposure, aperture, iso, focal\_length, flash, orientation, gps\_lat, gps\_lon, gps\_altitude | | `iptc` | object / null | IPTC data: copyright, keywords, caption, byline, headline, category, supplemental\_category | | `xmp` | object / null | XMP data: creator, rights, rating, dc\_title, dc\_description, dc\_date | | `gps_address` | string / null | Human-readable address from reverse geocoding (only when include\_gps is true) | | `stripped_image` | string / null | Base64-encoded clean image bytes (only in strip or both mode) | | `has_gps` | boolean | Whether GPS coordinates were found in the EXIF data | | `warnings` | array | Non-fatal warnings (fetch failures, unknown format, corrupt EXIF entries) | | `error` | string / null | Fatal error for this image (fetch failure, processing crash with traceback) | #### Example output (extract mode) ```json { "filename": "vacation.jpg", "format": "JPEG", "width": 4032, "height": 3024, "file_size_bytes": 2847612, "color_mode": "RGB", "exif": { "camera_make": "Apple", "camera_model": "iPhone 15 Pro", "date_taken": "2024-06-15T14:22:31", "exposure": "1/120", "aperture": "f/1.8", "iso": 80, "focal_length": "6.8mm", "flash": "No Flash", "orientation": 1, "gps_lat": 51.4545, "gps_lon": -2.5879 }, "iptc": { "copyright": "© 2024 Example Photographer", "keywords": ["vacation", "summer", "beach"], "caption": "Sunset at the harbour" }, "xmp": null, "gps_address": "Princes Wharf, Wapping Road, Spike Island, Bristol, City of Bristol, West of England, England, BS1 4RN, United Kingdom", "has_gps": true, "stripped_image": null, "warnings": [], "error": null } ``` *** ### FAQ **Q: Which image formats are supported?** A: JPEG, PNG, TIFF, WebP, and HEIC/HEIF. Format detection uses magic bytes at the start of the file, not file extensions. **Q: Does GPS reverse geocoding cost extra?** A: Reverse geocoding uses the OpenStreetMap Nominatim API. It is only performed when `include_gps` is true and the image actually contains GPS data. **Q: What happens if stripping fails on a particular format?** A: The stripped image field will be null but all other metadata fields will still be populated. The image is never modified in-place — the original bytes are always available through the extraction fields. **Q: Can this handle images larger than 20 MB?** A: No. Images exceeding 20 MB are skipped with a warning. This prevents memory issues when processing very large files. **Q: Is the base64 output from stripping suitable for embedding in HTML?** A: Yes. The base64 output is standard and can be used directly in `data:` URIs or HTML `src` attributes. **Q: Does stripping preserve image quality?** A: Yes. Stripping only removes metadata markers from the binary structure — the actual pixel data is never touched. The image quality is identical to the original. **Q: How is orientation handled when stripping?** A: JPEG stripping preserves the EXIF orientation tag so the image displays correctly after stripping. Set `strip_preserve_orientation` to false if you want the orientation tag removed as well (the image may rotate in viewers that honour it). *** ### API Usage #### cURL ```bash curl -X POST "https://api.apify.com/v2/acts/perryay~image-metadata-analyzer/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "images": ["https://example.com/photo.jpg"], "mode": "extract", "include_gps": true }' ``` #### Python ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") run = client.actor("perryay~image-metadata-analyzer").call( run_input={ "images": ["https://example.com/photo.jpg"], "mode": "extract", "include_gps": True, } ) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["exif"]["camera_model"]) if item.get("exif") else None ``` #### Node.js ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_API_TOKEN' }); const run = await client.actor('perryay~image-metadata-analyzer').call({ images: ['https://example.com/photo.jpg'], mode: 'extract', include_gps: true, }); const dataset = client.dataset(run.defaultDatasetId); for await (const item of dataset.iterateItems()) { console.log(item.format, item.width, '×', item.height); } ``` *** ### Use Cases - Stripping GPS coordinates from photos before sharing them on social media or public forums - Auditing your own website to check if uploaded images leak device serial numbers or location data - Building a privacy-first image upload pipeline that automatically scrubs metadata on ingestion - Indexing a photo library by camera model, date taken, and copyright holder from EXIF and IPTC - Verifying the provenance of images submitted by sources — does the camera and timestamp match the story? - Extracting GPS coordinates from field photos and reverse-geocoding them to addresses for reports - Generating clean, metadata-free thumbnails for public-facing product images - Processing batch submissions from users who want to share photos but don't know what metadata their phone embeds # Actor input Schema ## `images` (type: `array`): Array of image URLs or base64 data URIs to analyze. Supported formats: JPEG, PNG, TIFF, WebP, HEIC/HEIF. Max 50 images per run. ## `mode` (type: `string`): Operation mode: 'extract' reads metadata only, 'strip' removes all metadata and returns clean images, 'both' does both operations. ## `include_gps` (type: `boolean`): If true, GPS coordinates (when present in EXIF) are reverse-geocoded to a human-readable address using OpenStreetMap Nominatim. Disabled by default for privacy and speed. ## `strip_preserve_orientation` (type: `boolean`): When stripping metadata (mode=strip or both), keep the EXIF orientation tag so the image displays at the correct rotation. Set to false to remove the orientation tag as well. ## Actor input object example ```json { "images": [ "https://example.com/photo.jpg", "data:image/jpeg;base64,/9j/4AAQ..." ], "mode": "extract", "include_gps": false, "strip_preserve_orientation": true } ``` # Actor output Schema ## `results` (type: `string`): Image metadata results # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "images": [ "https://example.com/photo.jpg", "data:image/jpeg;base64,/9j/4AAQ..." ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/image-metadata-analyzer").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "images": [ "https://example.com/photo.jpg", "data:image/jpeg;base64,/9j/4AAQ...", ] } # Run the Actor and wait for it to finish run = client.actor("perryay/image-metadata-analyzer").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "images": [ "https://example.com/photo.jpg", "data:image/jpeg;base64,/9j/4AAQ..." ] }' | apify call perryay/image-metadata-analyzer --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/image-metadata-analyzer", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Image Metadata Analyzer & Privacy Stripper", "description": "Extract EXIF (GPS, camera, exposure), IPTC (copyright, keywords), XMP (rights, creator) metadata from images. Privacy mode strips all metadata and returns clean base64 image bytes. GPS to human-readable address via reverse geocoding. Supports JPEG, PNG, TIFF, WebP, HEIC/HEIF.", "version": "1.0", "x-build-id": "DF0dsPwrBWsd7SHbu" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~image-metadata-analyzer/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-image-metadata-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/perryay~image-metadata-analyzer/runs": { "post": { "operationId": "runs-sync-perryay-image-metadata-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/perryay~image-metadata-analyzer/run-sync": { "post": { "operationId": "run-sync-perryay-image-metadata-analyzer", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "images" ], "properties": { "images": { "title": "Images", "maxItems": 50, "uniqueItems": false, "type": "array", "description": "Array of image URLs or base64 data URIs to analyze. Supported formats: JPEG, PNG, TIFF, WebP, HEIC/HEIF. Max 50 images per run." }, "mode": { "title": "Mode", "enum": [ "extract", "strip", "both" ], "type": "string", "description": "Operation mode: 'extract' reads metadata only, 'strip' removes all metadata and returns clean images, 'both' does both operations.", "default": "extract" }, "include_gps": { "title": "Include GPS Address", "type": "boolean", "description": "If true, GPS coordinates (when present in EXIF) are reverse-geocoded to a human-readable address using OpenStreetMap Nominatim. Disabled by default for privacy and speed.", "default": false }, "strip_preserve_orientation": { "title": "Preserve Orientation When Stripping", "type": "boolean", "description": "When stripping metadata (mode=strip or both), keep the EXIF orientation tag so the image displays at the correct rotation. Set to false to remove the orientation tag as well.", "default": true } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```