Check a file: for developers
How to call Jeevo's free "Check a file" from your own code, what it answers, its limits and how each mark is read. The same check runs behind https://api.jeevo.ai/check. Free, no account. Version 1.3.
Call the API
Send one file to https://api.jeevo.ai/v1/provenance/check with POST (the same check also answers at https://api.jeevo.ai/api/v1/provenance/check). There are three ways:
- the file's bytes as the request body, with any content type except JSON and multipart;
- a multipart form with the file in a part that has a file name or is named
file, or a link in a field namedurl; - JSON with a link,
{"url": "https://…"}: our server downloads the file.
curl --data-binary @picture.png https://api.jeevo.ai/v1/provenance/check
curl -F file=@video.mp4 https://api.jeevo.ai/v1/provenance/check
curl -H 'Content-Type: application/json' -d '{"url": "https://example.org/song.mp3"}' \
'https://api.jeevo.ai/v1/provenance/check?receipt=1'
We read pictures (PNG, JPEG, WebP, GIF, TIFF, AVIF, HEIC), videos (MP4, MOV), sound files (MP3, WAV, M4A) and documents (PDF, DOCX, PPTX, XLSX, ODT, ODP, ODS). The format is read from the file's first bytes, and for DOCX to ODS from the package's own content types, never from its name or content type. Jeevo's watermark is read in PNG, JPEG, WebP, MP4, MOV, MP3 and WAV; the other formats are checked for signed labels, and documents also for the AI label in their properties. Anything else gets 415 with unsupported_format.
Big files, in parts
One request can carry at most 104,857,600 bytes through the network in front of our server. A bigger file, or one close to that, can be sent in parts of up to 16,777,216 bytes. The parts are held in memory by the one server process that started the upload, never written anywhere, and dropped as soon as the file is checked, when you cancel, when no byte has arrived for 60 seconds, or when it cannot arrive whole within 600 seconds at its pace after the first 30.
- Start: POST to
https://api.jeevo.ai/v1/provenance/uploadswith JSON holdingsize, the file's total bytes (add?receipt=1for a signed receipt). The answer, 201, holds the upload's id inuploadand the largest part inpart_bytes. A start counts as one check against the limits and waits its turn as a check does; the upload then holds its turn until it ends. - Each part: PUT the part's raw bytes to
https://api.jeevo.ai/v1/provenance/uploads/upload?offset= with the number of bytes already received as the offset, one part at a time and in order. The answer holdsreceived. A wrong offset gets 409 withoffset_mismatchand thereceivedto go on from; GET on the upload says the same. - Commit: POST to
https://api.jeevo.ai/v1/provenance/uploads/upload/commit once every byte has arrived. The answer is the same as for one request with the whole file, receipt included. DELETE on the upload drops it at once.
An unknown upload, or one dropped for time, gets 404 with upload_not_found. A part over 16,777,216 bytes gets 413 with part_too_large, a part beyond the size you started with 400 with size_mismatch, a commit before the last byte 409 with incomplete. A part that reaches a server process other than the one holding the upload gets 421 with wrong_worker: send that part again.
An upload lives only in that server process. When we update or restart it, uploads in progress are dropped: their next part or commit gets 404 with upload_not_found. Sending the part again does not bring the upload back; start it again from the first byte.
size=$(stat -c %s video.mp4)
up=$(curl -s -H 'Content-Type: application/json' -d "{\"size\": $size}" \
https://api.jeevo.ai/v1/provenance/uploads | jq -r .upload)
split -b 16777216 -d video.mp4 part-
offset=0
for p in part-*; do
curl -s -X PUT --data-binary @$p "https://api.jeevo.ai/v1/provenance/uploads/$up?offset=$offset" > /dev/null
offset=$((offset + $(stat -c %s $p)))
done
curl -X POST https://api.jeevo.ai/v1/provenance/uploads/$up/commit
Limits
- Files and links up to 200 MB (209,715,200 bytes); a bigger one gets 413 with
too_large. An upload over the limit may be refused in front of our server with an HTML 413 page instead of our JSON. - Without a key: 10 checks in a row from one internet address, then 60 an hour (an IPv6 address counts by its /64). Over that, 429 with
rate_limitedand a Retry-After header in seconds. - Checks wait their turn on each server process in a short queue; a queued request waits up to 45 seconds, longer than the slowest check (a video). A request that finds the queue full, or waits longer, gets 503 with
busyand Retry-After. When another check or Jeevo's own marking holds the server's watermark reader longer than 45 seconds, the answer still comes, withbusyas the watermark's reason (and verdictnot_readwhen the file carries no label). - A link must be public http or https. We follow at most 5 redirects, each to a public address, and give up after 30 seconds (
bad_url,url_not_public,url_fetch_failed).
Free unlimited checks for authorities and researchers
Market surveillance and other authorities, law enforcement, the media, fact-checkers, trusted flaggers, independent researchers, schools and universities, and civil society organisations get a key free of charge. Write to hello@jeevo.ai from your organisation's address and say who you are: there is no form and no account. Send the key in the X-Jeevo-Check-Key header. It lifts the limit on how many files you check, with no volume limit; the size limit stays.
curl -H 'X-Jeevo-Check-Key: <your key>' --data-binary @picture.png https://api.jeevo.ai/v1/provenance/check
The answer
A JSON object (200) of codes and facts, never sentences: the page puts them into words. It is never cached (Cache-Control: no-store). Fields may be added later; ignore the ones you don't know.
| Field | What it means |
|---|---|
format, kind, size | The format read from the bytes (a media type); image, video, audio or document; the size in bytes. |
checked_at | When the check ran (UTC, ISO 8601, to the second). |
verdict | One word for the headline, decided in this order:
|
marks.jeevo_manifest | Jeevo's signed label. found says whether it is there. When it is: made_at (the time stamp authority's time, else the signer's), model and model_vendor (the model that made the file and its maker), digital_source_type (the IPTC term), ai_generated, time_stamped, watermark_recorded (the label says Jeevo's watermark was added) and changed_after_signing (the content changed after Jeevo signed it). |
marks.jeevo_watermark | Jeevo's hidden watermark. read says whether it could be read; when not, reason says why: format (not read in this format), busy (try again), unavailable or unreadable. When read: found, and bits of total message bits matched. |
marks.vendor_manifests | Every other maker's signed label in the file's C2PA chain, newest first: vendor (the maker's everyday name), signer (the certificate's organisation), generator (what made it, in the maker's words), made_at, digital_source_type, ai_generated, trusted, inside_jeevo_label and from_input. trusted is true or false for the newest label only (is its certificate on the C2PA Trust List) and null inside a newer label. from_input is true for a label that came with the picture the file was made from (a video made from a photo keeps the photo's label as an inputTo ingredient): it says who made that picture, not who made this file. |
marks.jeevo_claims_unsigned | Labels that name Jeevo without Jeevo's signature, with signer and reason: not_signed_by_jeevo, or inside_other_label (inside someone else's newer label, so it can't be confirmed). |
marks.document_label | The AI label in a document's own properties (DOCX, PPTX, XLSX, ODT, ODP, ODS). read is false for every other format, with reason format. When read: found, where (ooxml_custom_properties or odf_user_defined), signed (always false), digital_source_type (the IPTC term, or the value as written when it is not one, cut at 120 characters), iptc (it is an IPTC term), ai_generated, ai_system and ai_provider (as written in the file). |
manifest_present | true when the file carries any C2PA label we could read. |
receipt | Only with ?receipt=1: the signed receipt (below). |
error | On a 4xx or 5xx answer, the only field, a code: no_file, bad_request, bad_url, url_not_public, url_fetch_failed, too_large, unsupported_format, document_too_complex, document_unreadable, rate_limited, busy, unavailable or receipt_unavailable. |
How each mark is read
Signed labels (C2PA Content Credentials)
Read with c2pa-python, the C2PA reference SDK, following the C2PA specifications. A label counts as Jeevo's only when it is the file's newest label and its signature chains to Jeevo's own root certificate, jeevo-root.pem (Incremental AS): anyone can write "Jeevo" into a label, so the name alone proves nothing. Jeevo's label carries the IPTC digital source type in its actions, our own no.incremental.jeevo.ai_generated assertion with the model and its maker, a c2pa.watermarked action and an RFC 3161 time stamp.
Other makers' labels are named by their certificate's organisation and checked against the C2PA Trust List. The reader checks the certificate of the newest label only; a label kept inside it comes with the results its outer signer recorded, so it is reported without a trust answer.
Jeevo's watermark in pictures and video
Meta's Video Seal 1.0 (MIT licence, weights included), the 256-bit TorchScript model. Found when at least 180 of the 256 message bits match; on 200 files people made, none read more than 151. Pictures and video frames are scaled to fit 1920 pixels, and at most the first 64 frames of a video are read. Jeevo's label names the mark as soft binding no.incremental.jeevo.videoseal-1.0.
Jeevo's watermark in sound
Meta's AudioSeal 0.2.1 (MIT licence, weights included), 16 bits at 16 kHz. Found when the detector calls at least 50 % of the sound marked and at least 15 of the 16 message bits match. The first 120 seconds are read. Soft binding no.incremental.jeevo.audioseal-0.2. Jeevo does not watermark the sound track of a video yet; its picture is watermarked.
The message is the same in every file and says only that Jeevo made it: the first 256 bits (16 for sound) of the SHA-256 of no.incremental.jeevo/watermark/v1. It says nothing about the person, the prompt or the time. Both models are public, so you can run the same detectors yourself.
Documents
A PDF's signed label is read like a picture's, from the C2PA manifest embedded in the PDF; there is no watermark in documents. Word, PowerPoint and Excel files (DOCX, PPTX, XLSX) and OpenDocument files (ODT, ODP, ODS) from Jeevo carry no signed label for now: they say AI made them in their own properties, the IPTC digital source type in a DigitalSourceType property, with AISystem and AIProvider next to it (custom document properties in OOXML, meta:user-defined fields in ODF meta.xml). That label is not signed, so it is reported as a property label and never as Jeevo's signed label. A package with a C2PA manifest (META-INF/content_credential.c2pa) has it read as well.
A document is a ZIP package, so it is never unpacked whole. More than 20,000 entries or a directory over 8 MB is refused before any entry is read; only the parts that say what the file is and hold the label are opened, each up to 1 MB once inflated, stored or deflated and never encrypted; the XML is read without a DTD. A package over these limits gets 422 with document_too_complex, a broken one 422 with document_unreadable.
Other makers' hidden marks
Other makers' invisible marks (Google's SynthID, ElevenLabs', OpenAI's, Meta's) can only be read by their own checkers:
For other detectors: the C2PA soft binding API
Detection tools that follow C2PA can ask about Jeevo's watermark through the standard Soft Binding Resolution API (version 2.5.0) at https://api.jeevo.ai/v1/softbinding. It answers from Jeevo's own reader and never passes a request on to another service.
/services/supportedAlgorithmslists the two algorithms it answers for:no.incremental.jeevo.videoseal-1.0(pictures and video) andno.incremental.jeevo.audioseal-0.2(sound). They are the names Jeevo's labels give the watermark./matches/byBinding(GET withalgandvalue, or POST the same as JSON): the watermark message your own detector read, base64, 256 bits for pictures and video, 16 for sound. It matches at 180 or 15 equal bits, the same thresholds as Jeevo's reader. An algorithm that is not Jeevo's gets an empty list./matches/byContent(POST the file) and/matches/byReference(POST JSON with a publicreferenceUrl, itsassetLengthandassetType): Jeevo reads the watermark as this check does, within the same size and rate limits, and keeps nothing.
A match names the manifest urn:c2pa:3d61bc7f-bb07-413e-b670-cf0ed0984ffa. /manifests/{manifestId} returns it as a C2PA manifest store signed by Incremental AS. It says what the watermark means, made with AI by Jeevo, and carries both soft bindings. It describes the mark, not one file, because Jeevo keeps no record of the files it makes. It is bound to reference-asset.png.
curl https://api.jeevo.ai/v1/softbinding/services/supportedAlgorithms
curl --data-binary @picture.png -H 'Content-Type: image/png' \
https://api.jeevo.ai/v1/softbinding/matches/byContent
The watermark is also the signpost: its model, its message and its thresholds are on this page, so any detector can recognise Jeevo's mark without asking us.
Signed receipt
Add ?receipt=1 to the request (the page's "Download a signed receipt" does) and the answer also carries receipt: a JWS (RFC 7515, compact form, ES256) signed by Jeevo, with the same result. Nothing is kept: the hash is computed while your file is in memory and exists only in the answer. When the server has no receipt key, the request gets 503 with receipt_unavailable before anything is read or counted.
The signed payload holds content (the file's sha256, size and format), detector (name, version, the page's and the API's URLs, and the readers' versions and model digests), checked_at, verdict, manifest_present and marks, as in the answer. payload next to jws is a readable copy: only jws is signed.
The certificate travels in the JWS header (x5c) and is published at receipt-certificate.pem; Jeevo's root, jeevo-root.pem, issued it. To check a receipt, verify the certificate against the root and the signature with the certificate, then compare the SHA-256 with your file's:
import json, jwt # pip install pyjwt cryptography
from cryptography import x509
receipt = json.load(open("jeevo-check-receipt.json"))
chain = x509.load_pem_x509_certificates(open("receipt-certificate.pem", "rb").read())
root = x509.load_pem_x509_certificate(open("jeevo-root.pem", "rb").read())
chain[0].verify_directly_issued_by(root) # the receipt certificate is Jeevo's
body = jwt.api_jws.decode(receipt["jws"], chain[0].public_key(), algorithms=["ES256"])
print(json.loads(body)["content"]["sha256"]) # compare: sha256sum your-file
Report a marking fault
If a file Jeevo made shows no mark, if a result is wrong, or if the page or the API misbehaves, write to hello@jeevo.ai. Say what you checked and what you expected, and attach the signed receipt if you have one: its SHA-256 identifies the file without sending it. We look into every report and fix a confirmed fault.
What is kept
Nothing of the file. It is read in memory for the length of the check and dropped. It is never written to disk, and no log line carries the file, its name, its link, its hash or your address. To stop abuse, checks are counted per address for up to an hour, in memory only, as a one-way code.