EXIF API
The EXIF API reads the embedded EXIF, TIFF, IFD0 and GPS metadata from JPEG, PNG, HEIC, TIFF and WebP images. Point it at an image URL or POST the raw bytes and receive a clean, predictable JSON envelope with camera make and model, lens, capturing software, ISO, aperture, shutter speed, focal length, flash status, pixel dimensions and the original capture timestamp.
Built on Cloudflare Workers, the API runs at the edge for low-latency responses worldwide and never stores your images — bytes are parsed in-memory and discarded. URL fetches follow redirects, enforce a 15MB size cap and include a built-in SSRF guard that blocks localhost and private-network targets by default.
Free tier · no credit card · billed on RapidAPI
Key features
- Extract EXIF, TIFF, IFD0 and GPS metadata in one call
- Two input modes: image URL or raw binary upload
- Decimal GPS latitude, longitude and altitude when present
- Normalized top-level fields plus a full raw tag dump
- Supports JPEG, PNG, HEIC, TIFF and WebP images
- Built-in SSRF guard blocks localhost and private networks
- Images parsed in-memory and never stored
Perfect for
- Photo-management and gallery applications
- Content moderation and image provenance pipelines
- Real-estate and e-commerce listing tools
- Journalism and OSINT verification workflows
- Metadata strip-checks before publishing
- Geotagging and map-based photo organization
- Digital forensics and authenticity analysis
- Camera and lens analytics dashboards
EXIF API Documentation
Everything you need to integrate — base URL, auth, and copy-paste examples.
The EXIF API extracts EXIF, TIFF, IFD0 and GPS metadata from images supplied either as a raw binary upload or by URL. The API returns a normalized JSON envelope with consistent top-level fields (null when a tag is missing) plus a full raw object containing the complete parsed tag set for power users.
Base URL
https://edge-apis.e9736.workers.devAuthentication
Authenticate by appending your API key as a query parameter. When subscribing through RapidAPI, the proxy supplies the key and you send the standard RapidAPI headers instead:
// Direct (query parameter)
GET /exif/v1/extract?url=https://example.com/photo.jpg&apikey=YOUR_KEY
// RapidAPI proxy (headers)
{
"X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY",
"X-RapidAPI-Host": "exif-api.p.rapidapi.com"
}Request & response
GET /exif/v1/extract?url=https://example.com/photo.jpg&apikey=YOUR_KEY HTTP/1.1{
"found": true,
"make": "Apple",
"model": "iPhone 13 Pro",
"lens": "iPhone 13 Pro back triple camera 5.7mm f/1.5",
"software": "16.5.1",
"datetime": "2023-07-14T18:32:07.000Z",
"orientation": 6,
"iso": 64,
"f_number": 1.5,
"exposure_time": 0.008333333333333333,
"focal_length": 5.7,
"flash": "No Flash",
"dimensions": { "width": 4032, "height": 3024 },
"gps": {
"latitude": 37.80861111111111,
"longitude": -122.40972222222223,
"altitude": 12.4
}
}Code examples
# Extract from an image URL
curl --request GET \
--url 'https://exif-api.p.rapidapi.com/exif/v1/extract?url=https://example.com/photo.jpg' \
--header 'X-RapidAPI-Key: YOUR_RAPIDAPI_KEY' \
--header 'X-RapidAPI-Host: exif-api.p.rapidapi.com'
# Or upload raw bytes directly
curl --request POST \
--url 'https://exif-api.p.rapidapi.com/exif/v1/extract' \
--header 'X-RapidAPI-Key: YOUR_RAPIDAPI_KEY' \
--header 'X-RapidAPI-Host: exif-api.p.rapidapi.com' \
--header 'Content-Type: application/octet-stream' \
--data-binary @photo.jpgEndpoints
GET /exif/v1/extract
Extract metadata from an image URL passed via the url query parameter.
/exif/v1/extract?url=https://example.com/photo.jpg&apikey=YOUR_KEYPOST /exif/v1/extract
Extract metadata from a raw image body (image/* or application/octet-stream) or a JSON object { "url": "https://..." }.
/exif/v1/extractGET /exif/health
Health check that confirms the service is up.
/exif/healthQuery Parameters
Required Parameters
url- HTTP/HTTPS URL of the image to analyze. Required for the GET endpoint (or pass the image bytes / JSON { url } on POST).
Optional Parameters
timeout_ms- Upstream fetch timeout in milliseconds. Default 10000, maximum 20000.block_private- SSRF guard that rejects localhost and private-network hosts. Defaults to true; set false to override.
EXIF API Pricing
Choose the right plan for your image metadata needs with flexible pricing options and no hidden fees
Basic
- URL and binary-upload modes
- GPS extraction
- Full raw tag dump
Pro
- URL and binary-upload modes
- GPS extraction
- $0.30 per 1,000 extra requests
Ultra
- Priority routing
- $0.15 per 1,000 extra requests
- 20× more than Pro plan
Need higher volume or a custom SLA?
Talk to us about enterprise rates, dedicated support, and compliance docs.
Frequently asked questions
The API reads embedded metadata from JPEG, PNG, HEIC, TIFF and WebP images. It parses EXIF, TIFF, IFD0 and GPS directories using the exifr library running on Cloudflare Workers. If an image contains no readable metadata, the response is simply { "found": false }.
Both modes are supported. Send a GET request with the url query parameter to have the service fetch and analyze a remote image, or POST the raw image bytes directly with a Content-Type of image/* or application/octet-stream. You can also POST a JSON body of the form { "url": "https://..." } if you prefer JSON over query parameters.
Yes. When an image carries GPS tags, the response includes a gps object with decimal latitude, longitude and (when present) altitude. The API converts the file's raw degrees-minutes-seconds representation into decimal degrees that are ready to plot on a map. Images without GPS data return gps as null.
Yes. The API enforces a 15MB size cap on fetched and uploaded images. Requests for images that exceed this limit return a 413 response. URL fetches also follow redirects, send a realistic browser User-Agent, and honor a configurable timeout (timeout_ms, default 10000ms, maximum 20000ms).
No. The EXIF API never stores your images. Bytes are parsed in-memory on the edge and discarded immediately after the response is returned. URL fetches are protected by a built-in SSRF guard that blocks localhost and private-network targets by default, which you can override with the block_private parameter when needed.
Every response includes a consistent set of normalized top-level fields — make, model, lens, software, datetime, orientation, iso, f_number, exposure_time, focal_length, flash, dimensions and gps — which are null when a tag is missing. The raw object contains the complete sanitized parser output with every recognized tag (dates ISO-stringified, binary dropped), giving power users access to fields beyond the normalized set.
Related APIs & tools
Other services that pair well — all on the same key.
Document Parser API
Extract structured data from invoices, receipts and resumes with AI-powered parsing.
Learn more→DNS Lookup API
Query DNS records with support for forward and reverse lookups across all record types.
Learn more→Text Analysis API
Analyze text for sentiment, language, entities and readability with a single call.
Learn more→Every week you build in-house is a week you don't ship product
2,500+ teams already made the switch. Start with a free tier today, or talk to us about your enterprise needs.
For developers
Free tier, no credit card. Integrate your first API in under 30 minutes.
Get API keys freeRead the docsFor teams and enterprise
Custom volumes, SLA guarantees, dedicated support, and compliance documentation.
Talk to salesor email sales@apicodex.io