Image Normalization API

Normalizes each supplied image — auto-rotate by EXIF, resize to a max dimension, convert format, compress, and strip unsafe metadata — and returns the normalized artifact plus before/after dimensions, color mode, MIME, byte sizes, and SHA-256s. Upload-driven; there is no search or discovery source.

What you submit

images — images (base64, data: url, kvs key, or permitted image url). Each item is an image supplied as a base64 string, a data: URL, a key naming an entry in the run key-value store, or a permitted direct http(s) image URL (URL items pass the per-origin runtime gate — robots + SSRF — before any fetch; there is no search/discovery source). Per image ONE normalized artifact (stored in the run key-value store) plus before/after dimensions, color mode, MIME, byte sizes, SHA-256s, the operations applied, and warnings. Operations: auto-rotate by EXIF, resize to a max dimension, convert format, compress, and strip unsafe metadata. Guards: format allowlist, a pixel-count cap, and a decompression-bomb guard. A completed normalized image bills; a corrupted, oversized, or disallowed-format input, or a blocked/unreachable URL, is an unbilled status.

The runtime source gate (per submitted target)

You choose the targets, so the source contract is enforced at run time — for every URL-mode item (base64 / data: URL / key-value-store items are local and are not fetched) — per origin, before any page is read:

• robots.txt fetched once per origin and honored; no robots / 404 = permitted, a disallowed path or an unavailable/forbidden robots file = BLOCKED.
• SSRF guard — every host is resolved and must be public; private, loopback, link-local, reserved and cloud-metadata addresses are refused before a socket opens.
• HTTP — 403 / 429 / 5xx = BLOCKED; DNS / timeout / connection faults = UNREACHABLE.

A BLOCKED or UNREACHABLE target is delivered as an unbilled status row — never a broken-site verdict, and never charged.

Untrusted-file guards

Every image is treated as untrusted: a byte-size cap and a pixel-count cap (checked from the declared dimensions before the image is decoded) guard against decompression bombs, and only an allowlisted set of input formats is accepted.

Output & billing

One row per image. A completed normalization carries outcome: answer and bills once. A corrupted, oversized, or disallowed-format input, or a blocked / unreachable URL, is delivered as an unbilled status. Push-then-charge: every row is delivered before its charge, so a billing hiccup can only ever undercharge.

Pricing

Event	Price	When
apify-actor-start	$0.02	once when the run starts (reserved; never charged in code)
image_normalization_check	$0.05	once per completed normalized image (rejected / blocked / unreachable never bill)

Volume tiers reduce the per-verdict price as usage grows: $0.05 → $0.045 → $0.04 → $0.0335.

Why this and not the obvious alternative

a deterministic normalized image artifact (auto-rotate, resize, convert, compress, strip unsafe metadata) with before/after hashes and dimensions and hard pixel/byte bomb guards — an upload-driven normalization API, not an image search or scraper.