JPEG Image Metadata Audit and EXIF Cleaner

An image metadata remover for authorized JPEG batches: inspect segment inventories or remove EXIF APP1 segments without decoding or re-encoding pixels. Receive one audit row per attempted image, scan-preservation hashes and cleaned JPEG download references.

Who is this for?

Publishing teams, photographers and developers who need a repeatable EXIF-cleaning step before distributing JPEG files. Use it for supplied files you own or are authorized to process, not for finding or collecting other people's images.

Why use this Actor?

The cleaner works on compressed bytes, not a pixel reconstruction. Every non-EXIF segment and every scan byte remains unchanged. Before/after inventories make the operation auditable. Hashes provide a preservation check rather than a vague promise of an unchanged picture.

This is not a universal privacy scrubber. It does not detect or remove visible or invisible watermarks, AI labels, C2PA credentials, XMP, IPTC, comments or ICC profiles. It makes no undetectability or provenance-evasion claims.

Getting started

1. Choose clean to remove EXIF or audit to inspect without producing a file.
2. Add an images array of source objects. Each object needs exactly one url, base64 or key.
3. Set maxItems, the maximum number of entries attempted in input order.
4. Run the Actor and inspect the default dataset.
5. For successful clean rows, download the cleanedUrl or retrieve cleanedKey from that run's key-value store.

The Console prefill contains a small generated JPEG with a synthetic EXIF segment, so you can test the complete cleaning workflow without an external image server.

Input parameters

Input	Default	Behavior
images	required	1–200 objects; one source per object
mode	clean	clean removes EXIF and stores files; audit only reports
maxItems	20	Global attempted-entry cap, 1–200; includes errors and duplicates

Source objects:

• url: public HTTPS JPEG, port 443 only, no embedded credentials. Signed URL queries can be supplied but are not exported. Private/reserved addresses are rejected, DNS is pinned to a vetted resolution, and each redirect is checked.
• base64: canonical padded base64, optionally prefixed with data:image/jpeg;base64,. No whitespace or alternative media prefix.
• key: binary JPEG record in this run's default key-value store.
• storeId: optional accessible KV store ID/name, only with key. Use this for files already stored by another authorized run.

There is no source precedence: supplying multiple source fields is an error. Empty arrays, unknown fields, unsupported modes and zero/unlimited caps are rejected. Entries after the cap are neither fetched nor processed. Duplicate entries are processed and charged separately.

Output

Field	Meaning
index, sourceType	Input position and source route; no raw source value
status, error	ok or safe error detail
inputBytes, outputBytes	File sizes
removedExifSegments	Number removed; zero in audit mode
segmentsBefore, segmentsAfter	Ordered markers/entropy blocks with offsets, lengths and kinds
scanCount	Number of compressed scans
scanSha256Before, scanSha256After	SHA-256 over each entropy block prefixed by its four-byte big-endian length
scanPreserved	Matching scan hash and count; not a privacy guarantee
inputSha256, outputSha256	SHA-256 of complete original/result files
cleanedKey, cleanedUrl	Run-local stored JPEG reference; null in audit mode
processedAt	Processing timestamp

Error rows omit success-only fields and have no per-image charge. Inventories disclose segment existence and byte sizes, not raw tag values. Download access follows Apify storage permissions; never assume a private file is accessible to another user simply because a URL exists.

Example output

For the generated prefill JPEG, cleaning removes one EXIF segment and preserves the scan:

{
  "index": 0,
  "mode": "clean",
  "status": "ok",
  "sourceType": "base64",
  "removedExifSegments": 1,
  "scanCount": 1,
  "scanPreserved": true,
  "cleanedKey": "cleaned-0"
}

This is a subset of a real local result. Full rows also contain segment arrays and 64-character SHA-256 hashes.

How much does it cost to clean JPEG EXIF metadata?

Pay-per-event pricing has one start event per validated run and one primary item event per successfully audited or cleaned JPEG. Both operations use the same price. Error rows are free of item charges; the start fee still applies when valid input yields only errors.

BRONZE pricing is $0.001 per run plus $0.0016 per image. Examples: 1 image $0.0026, 10 images $0.017, 100 images $0.161.

Spend tier	Price per successful image
FREE	$0.00184
BRONZE	$0.0016
SILVER	$0.001248
GOLD / PLATINUM / DIAMOND	$0.00096

The $0.001 start fee is the same at every tier. Spend tiers depend on qualifying aggregate monthly Apify Store spend, not on this Actor's batch volume. Your applicable tier and charge ceiling govern the invoice; stop at a charge limit rather than treating incomplete results as complete.

Limits and failure behavior

• JPEG only: baseline, extended sequential and progressive Huffman frames. Not PNG, WebP, HEIC, arithmetic JPEG, TEM markers, JPEGs with zero-height frames or concatenated/trailing data.
• 8 MiB maximum per file. At most 200 entries; files are processed sequentially.
• HTTPS downloads have a 20-second deadline per request and at most three redirects. No retries, login, browser rendering or proxy fallback. Supply bytes/KV instead for authorized files behind access controls.
• Structural marker validation is not full entropy decoding. It cannot prove that an already-corrupt file renders correctly.
• EXIF orientation is removed too. Pixels are not rotated: viewers may display the cleaned file differently if they previously relied on its EXIF orientation. EXIF thumbnails are removed with the EXIF segment.
• XMP orientation, ICC profiles, comments and all other non-EXIF data remain. Do not use this as a guarantee that a file contains no identifying information.
• Individual loading/format errors generate rows and allow the rest of the batch to continue. If no JPEG succeeds, the run fails with error rows available. Storage or billing failures fail the run; outputs may be partial.

Integrations

Use n8n or Make to supply approved publishing assets, read successful dataset rows and retrieve cleaned files into your publishing pipeline. Retain the scan hashes alongside your asset records as an audit trail. Filter status=ok before downstream publication and review non-EXIF metadata separately.

Run through the Apify API for CI publishing pipelines. No external image-processing API or AI provider is used at runtime, and no additional processing key is required.

API usage

Save an input JSON file (for example the Console prefill), then invoke:

curl -X POST 'https://api.apify.com/v2/acts/automation-lab~image-metadata-audit-cleaner/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' --data-binary @input.json

JavaScript:

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/image-metadata-audit-cleaner').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 20 });

Python:

from apify_client import ApifyClient
import os
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/image-metadata-audit-cleaner').call(run_input=input_data)
items = client.dataset(run['defaultDatasetId']).list_items(limit=20).items

Retain the run ID and storage IDs. A start response is not the result dataset. Check terminal status and retrieve files from that same run; do not start another run merely to poll.

MCP: Claude Code, Claude Desktop, Cursor and VS Code

Select the stable Actor-specific subset:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/image-metadata-audit-cleaner"

Equivalent HTTP configuration for Claude Desktop, Cursor and VS Code clients that support remote MCP (adapt the outer key to the client's format):

{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/image-metadata-audit-cleaner"
    }
  }
}

Authenticate using the client's supported Apify flow. Discover actual names/argument schemas with scoped tools/list; this selection includes run/dataset/KV retrieval and abort helpers too. Discovery is not permission to execute or abort.

Example prompt: “Audit these authorized JPEGs without modifying them; report whether EXIF segments are present.” Or: “Clean these approved JPEG assets; return download references and scan-preservation results, and flag errors.”

Start once with authorization. Keep the run ID. If nonterminal, use get-actor-run on that same ID with bounded 2/4/8-second backoff capped at 10 seconds and a 120-second total deadline. Configure client timeouts longer than the server wait plus transport margin. At timeout, recover the known run rather than restart; if its ID is unknown, report uncertainty. At deadline report pending and stop polling.

After success, retrieve untransformed JSON via get-dataset-items, with explicit limit/offset/fields. For example, process pages of 20 source rows host-side, admitting at most 100 rows or 64 KiB of serialized UTF-8 into model context. Enforce byte limits before model injection, including oversized rows. Report truncation and the source continuation offset. Full file exports stay outside model context. Clients without interception cannot promise a hard byte limit. No numeric token-saving claim is made.

Legality, privacy and retention

Only process files you are authorized to use. Do not upload unlawful material or use cleaning to misrepresent provenance, ownership or authenticity. This is an independent utility, not an affiliation or certification.

Images can contain sensitive personal data in pixels and metadata. Input records remain in Apify run storage; clean output JPEGs and reports remain in the run's KV/dataset under your account's storage retention and deletion controls. The Actor does not automatically delete these records or set a fixed retention period. Delete the run's input, dataset and files when no longer needed; Apify backups/platform retention are governed by Apify, not this Actor. Intermediate buffers are memory-only and no cross-run cache is used. Source servers receive requests for supplied HTTPS URLs.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; the entire images field is redacted, including base64 and source keys. Reports are retained for 30 days. No supplied image bytes are sent to an AI provider. Icon artwork is generated separately from synthetic product descriptions, not customer data.

FAQ and troubleshooting

Does lossless mean all metadata is removed? No. Only EXIF-signature APP1 segments are removed. Other metadata and identifying pixels remain.

Why did orientation change? Some viewers use an EXIF orientation tag. Removing it does not rotate pixels. Normalize orientation in a separate conversion step if needed.

Why does my URL fail? Use public direct HTTPS JPEG links without authentication or private addresses. Anti-bot pages, redirects beyond the cap and non-JPEG payloads are unsupported; supply base64 or an accessible KV record instead.

Can I audit without creating a cleaned file? Yes, use mode: "audit". File references are null and byte hashes match.

Why is the run successful with error rows? At least one image succeeded. Check every row and never assume the whole batch succeeded from the run status alone.

Related Actors

For re-encoding, resizing or format conversion instead of scan-preserving cleaning, see Bulk Image Compressor and Bulk Image Format Converter.

Support

Use the Actor's Apify Issues tab for support. Include the run ID, operation and a safe reproducible example; do not post confidential image bytes, signed URLs or credentials publicly. Apify standard user terms apply; this README adds no custom end-user agreement.