Method and limits

ChronoVerify answers one question about a photo: when it was captured, where if it still carries location data, and whether it shows signs of editing. It returns one plain-language verdict, a 0 to 100 evidence-strength number, and the per-signal breakdown that produced it. It is provenance-first, works on any photo, signed or not, and is not a deepfake-only detector.

The verdicts

• Provenance confirmed: Content Credentials (C2PA) are attached and validated against the official trust list, meaning the signer chains to a recognized root.
• Consistent: metadata is present and internally consistent, and no manipulation signals fired. This is not proof of authenticity.
• Inconclusive: the image carries little or no provenance (common for screenshots and platform-stripped photos). The default when evidence is weak.
• Metadata anomaly: the metadata contains an internal contradiction worth review.
• Manipulation indicated: at least two distinct corroborating signals are jointly consistent with editing. Treat it as a triage flag for human review, never as a determination.

By design the verdict biases toward inconclusive, and no single pixel signal can produce a manipulation verdict. At least two distinct corroborating signals must agree.

The signals (method cards)

Limits of use

• Pixel forensics is probabilistic and degrades on recompressed, resized, screenshotted, or platform-stripped images. Absence of a signal is not proof of authenticity.
• A "consistent" or clean result confirms provenance integrity, not that the scene depicted is true. Many edits leave no detectable trace.
• The report authenticates the exact file we hashed. It does not establish where a photo came from, who took it, or how it was obtained. A human has to establish that foundation.
• For any contested or high-stakes use, a qualified examiner must interpret the signals and provide testimony. ChronoVerify supplies the reproducible, hashed substrate that the expert's opinion rests on.

Current status

As of this build: a deterministic verification pipeline and a signed-PDF report (Ed25519 over the canonical verdict, with an optional RFC 3161 trusted timestamp) are working. Cryptographic C2PA validation is active: embedded Content Credentials are checked against the official C2PA and CAI trust lists, a signer is confirmed only when it chains to a recognized trust anchor, and validation fails closed. A regression benchmark is in place: on a synthetic corpus the tool flags no authentic or normally re-saved image and returns "inconclusive" only on provenance-stripped images. Synthetic error-level analysis is not representative of real photos, so that set only checks that the verdict logic does not over-fire; it is not a detection measurement. Detection is demonstrated on real edits instead: the benchmark and calibration report documents how it is measured (no authentic capture in the corpus wrongly flagged, no known edit cleared as authentic, and most edits read as inconclusive for a human to review).

Not done yet: an independently reproduced, third-party benchmark is still pending, and no comparative claim against any competitor is made before a shared-input test exists; SOC 2 Type II and ISO 27001 are not held; a self-hosted deployment is planned.

API

One endpoint does the work: send an image, get the verdict object back as JSON. The public endpoint is keyless and free, rate limited per IP. For programmatic use, send your API key.

Get a key

A free key comes from POST /v1/keys/free with an email field: 100 verifications a month, no card, one key per email. For volume or signed reports, buy credits on the pricing page ($5 minimum). Your key, which starts with cv_live_, is shown once on the welcome screen right after payment. View usage and your credit balance any time on your dashboard. The same key works for every endpoint below.

Official libraries and AI agents

Skip the boilerplate with a maintained client, or wire ChronoVerify straight into an AI agent. The key is optional in every case: omit it to use the free, rate-limited public path.

JavaScript and TypeScript (npm: chronoverify):

npm install chronoverify

import { ChronoVerify } from "chronoverify";

const cv = new ChronoVerify("cv_live_...");
const r = await cv.verify({ file: "photo.jpg" });
console.log(r.verdict, r.confidence);

It ships a CLI too: npx chronoverify verify photo.jpg.

Python (PyPI: chronoverify):

pip install chronoverify

from chronoverify import Client

cv = Client("cv_live_...")
r = cv.verify(file="photo.jpg")
print(r["verdict"], r["confidence"])

With a CLI: chronoverify verify photo.jpg.

AI agents (MCP): give Claude Desktop, Cursor, Cline, or any MCP client a verify_image tool (npm: chronoverify-mcp). Add this to your MCP config:

{
  "mcpServers": {
    "chronoverify": {
      "command": "npx",
      "args": ["-y", "chronoverify-mcp"],
      "env": { "CHRONOVERIFY_API_KEY": "cv_live_..." }
    }
  }
}

Then ask the agent to "verify the provenance of this photo." It can pass a URL, a local file path, or base64 image bytes.

Prefer raw HTTP? The quickstart, with a verdict decision table for pipelines, lives in the developer docs; the full machine-readable spec is at /openapi.json. Plain curl, Python, and Node examples follow.

Verify an image

curl -X POST https://chronoverify.com/v1/verify \
  -H "Authorization: Bearer cv_live_..." \
  -F "file=@photo.jpg"

Or point it at an image already online:

curl -X POST https://chronoverify.com/v1/verify \
  -H "Authorization: Bearer cv_live_..." \
  -F "url=https://example.com/photo.jpg"

The url must be a direct link to an image. Redirects and hosts that block automated fetches are not followed (an SSRF safeguard), so if a URL fails with a 400, upload the file directly instead.

Shareable verdict links (opt-in)

curl -X POST https://chronoverify.com/v1/verify \
  -H "Authorization: Bearer cv_live_..." \
  -F "file=@photo.jpg" \
  -F "permalink=true"

With permalink=true the verdict (never the image) is also stored, and the response gains a permalink field with a shareable URL. Links are unlisted and never indexed: anyone with the link can view the verdict at /v/{id}, or fetch the raw record at /v/{id}.json. Links created with an API key do not expire; links from the free verifier expire after 90 days. Nothing is stored unless you opt in.

Python

import requests

r = requests.post(
    "https://chronoverify.com/v1/verify",
    headers={"Authorization": "Bearer cv_live_..."},
    files={"file": open("photo.jpg", "rb")},
)
data = r.json()
print(data["verdict"], data["confidence"])

Node.js

import fs from "node:fs";

const fd = new FormData();
fd.append("file", new Blob([fs.readFileSync("photo.jpg")]), "photo.jpg");

const res = await fetch("https://chronoverify.com/v1/verify", {
  method: "POST",
  headers: { Authorization: "Bearer cv_live_..." },
  body: fd,
});
const data = await res.json();
console.log(data.verdict, data.confidence);

The response

You get one JSON verdict object, the exact data the browser verifier renders. Abbreviated:

{
  "schema_version": "v1",
  "request_id": "9f2c1a7e4b...",
  "verdict": "consistent",
  "confidence": 61,
  "headline": "Metadata is internally consistent. No manipulation signals fired.",
  "summary": "The image carries metadata that is internally consistent and no manipulation signals fired...",
  "capture_time":     { "value": "2026-05-18T14:32:10", "source": "exif" },
  "capture_location": { "present": true, "lat": 37.7749, "lon": -122.4194,
                        "place": "San Francisco, California, United States",
                        "source": "exif" },
  "capture_device":   { "make": "Apple", "model": "iPhone 15 Pro", "source": "exif" },
  "c2pa":             { "present": false, "validated": null, "validation_state": null,
                        "signature_valid": null, "trust_list_match": null, "signer": null,
                        "note": "No Content Credentials (C2PA) found." },
  "metadata_consistency": { "exif_present": true, "xmp_present": false,
                            "checks": [ ... ], "anomalies": [] },
  "pixel_forensics":  { "estimated_jpeg_quality": 98, "ela_mean": 0.18, "ela_max": 7.4,
                        "ela_localization": 9.2, "noise_dispersion": 0.31 },
  "signals": [ { "name": "exif_present", "layer": "metadata",
                 "direction": "supports_authentic", "weight": 0.2,
                 "detail": "EXIF metadata is present and was parsed." } ],
  "integrity": { "sha256": "c255...ff53", "sha512": "0a1b...e9", "format": "JPEG",
                 "width": 1200, "height": 800, "bytes": 52083,
                 "processed_at_utc": "2026-05-18T20:15:04+00:00",
                 "pipeline_version": "chronoverify-pipeline-0.1.0",
                 "method_version": "fusion-0.1.0", "forensics_input": "original",
                 "c2pa_validator_enabled": true },
  "limits": "Investigative triage and risk scoring, not courtroom proof.",
  "processing_ms": 142
}

The signals array is the auditable trail: every check that moved the score, each with a layer (provenance, metadata, or pixel), a direction (supports_authentic, supports_edited, or neutral), a weight, and a human-readable detail. Branch your logic on verdict, and use confidence (0 to 100) for your own thresholds. The /openapi.json schema is the canonical contract; this example is abbreviated.

The c2pa object reports the cryptographic validation result. validation_state is Trusted (signature and content binding intact and the signer chains to a root on the official C2PA or CAI trust list), Valid (cryptographically intact but the signer is not on a trust list), or Invalid (tampered or broken). validated is true only when the state is Trusted; signature_valid is true for both Trusted and Valid; trust_list_match mirrors the trusted signer; and signer carries the issuer and common name when present. Validation fails closed: any error leaves these unverified.

Verdict values

Status codes

Headers, limits, and billing

• Keyed responses carry X-Credits-Remaining-USD (pay as you go) or X-Quota-Remaining (monthly plans), so you can track usage on every call. The /v1/report endpoint returns the same headers.
• Accepted formats: JPEG, PNG, WebP, AVIF, TIFF, HEIC, HEIF, GIF and BMP. Content Credentials can be carried by JPEG, PNG, WebP and AVIF; the rest are accepted for metadata and pixel checks. Maximum 25 MB and 40 megapixels per image (covers every phone's default output; 48MP pro modes need a downsize first).
• Free tier: 100 verifications per month, then $0.003 per image drawn from your prepaid balance. The public web verifier is always free.
• Signed PDF audit reports (/v1/report) are a premium unit at $2.00 each. On pay as you go each report draws $2.00 from your prepaid balance from the first one, because the free 100 a month covers verifications only; on a monthly subscription they come out of the plan's included quota instead.
• A failed image is never billed. You are metered only on a successful verification or report.

Signed PDF report

For a shareable, independently verifiable audit artifact, call /v1/report with the same key. It returns a signed PDF carrying the capture time, device, location, the signals, and the file hashes. The PDF embeds an Ed25519 signature over a file-derived view of the verdict, with an optional RFC 3161 trusted timestamp; verify it against the public key published at /v1/key. A signed report is a premium unit at $2.00 each from a prepaid balance, or included in a monthly subscription's quota, so it is the chain-of-custody record for audits and review files.

curl -X POST https://chronoverify.com/v1/report \
  -H "Authorization: Bearer cv_live_..." \
  -F "file=@photo.jpg" -o report.pdf

Interactive reference

An interactive API explorer lives at /docs, with the machine-readable schema at /openapi.json and a versioned JSON Schema of the verify response at /v1/verify.schema.json. The verdict you get from the API is the same object that renders in the public verifier, so the homepage doubles as a live example.

See also

Wire ChronoVerify into your stack from the integrations hub (MCP, OpenAI, Claude, LangChain, LlamaIndex, CrewAI, n8n, and REST), add the one-click MCP server, browse use cases by vertical, or look up a term in the glossary.