ForHosting KIT · Images

Read EXIF data

Every photo a camera or phone produces carries a quiet second file inside it — the camera model, the exact second it was taken, sometimes the exact coordinates where it happened. This endpoint reads that embedded metadata out of an image and hands it back as structured data, without touching a single pixel of the photo itself.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

The file inside the file

A JPEG or TIFF isn't just pixels — since the mid-1990s, cameras have embedded a standardized metadata block called EXIF alongside the image data, recording things the sensor knew at the moment of capture: make and model, exposure settings, orientation, timestamp, and, if location services were on, GPS coordinates. Most of the time nobody looks at it, but it's sitting there in every unmodified photo, waiting to be read by anything that knows to ask.

Who actually needs to read it

Photo management platforms sorting and timestamping large libraries by actual capture date rather than upload date, insurance and claims processes verifying when and roughly where a photo was taken, digital forensics and content-verification workflows checking a photo's origin data before trusting its stated context, real estate and inspection tools confirming that a site photo's GPS coordinates actually match the property it's supposed to be attached to.

What comes back from the read

You submit the image, receive a task_id right away, and the job returns the metadata fields present in the file — camera make and model, capture timestamp, orientation, and GPS latitude and longitude when present — as structured data, with nothing added, nothing inferred and nothing guessed whenever a field simply isn't there to begin with.

A quiet but essential automation step

Because it's a fast, flat-rate read with no image transformation involved, it fits as an early, cheap step in almost any photo pipeline: an upload arrives, EXIF is read first to timestamp and geotag it correctly, and only then does the image move on to storage, moderation, tagging or any further visual processing downstream.

Metadata that doesn't always survive

It's worth knowing going in that EXIF data isn't guaranteed — many social platforms and messaging apps strip it on upload for privacy reasons, and a screenshot or a re-saved, re-compressed image typically carries none at all. This endpoint reads faithfully whatever metadata the file actually contains; it can't recover what was already removed by another system before the photo ever reached it.

What you can do with it

Photo library organization

A media platform reads the capture timestamp from every uploaded photo to sort a library by when it was actually taken.

Insurance claim verification

A claims process reads the GPS coordinates and timestamp embedded in a submitted photo to check it matches the reported incident.

Content origin verification

A forensics or moderation workflow checks a photo's camera metadata and timestamp before treating its claimed context as reliable.

Field inspection confirmation

A property inspection tool reads GPS data from a site photo to confirm it was taken at the address it's attached to.

FAQ

How do I read EXIF data from an image with this API?

Send a POST to /image/exif-read with the image; the metadata fields present in the file come back as structured data by webhook or signed link.

Is there a free trial?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

How is it priced?

$0.002 per request, a flat published rate with no separate per-image component since no image transformation takes place.

Does every photo have GPS data in it?

No, GPS coordinates only appear if location services were enabled when the photo was taken; the field is simply absent otherwise.

Why doesn't my downloaded image have EXIF data?

Many social and messaging platforms strip EXIF metadata on upload for user privacy, so a re-downloaded photo often has none left to read.

Which formats carry EXIF metadata?

JPEG and TIFF files most commonly carry EXIF; some other formats support similar embedded metadata, but coverage and fields can vary.

Does this modify the image?

No, this is a read-only operation. The photo itself is never altered; only its existing metadata is extracted and returned.

Am I charged if the read fails?

No. A failed task is retried automatically up to three times and is never billed; you receive a clear error instead of a charge.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/image/exif-read

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/image/exif-read \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"image":"https://ejemplo.com/imagen.jpg"}'

const res = await fetch("https://api.kit.forhosting.com/image/exif-read", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "image": "https://ejemplo.com/imagen.jpg"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/exif-read",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "image": "https://ejemplo.com/imagen.jpg"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/exif-read", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"image":"https://ejemplo.com/imagen.jpg"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"image":"https://ejemplo.com/imagen.jpg"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/exif-read", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "image": "https://ejemplo.com/imagen.jpg"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.exif_read",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	15
`max_megapixels`	12

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →

Run — free