Skip to main content
0byte

Ship C2PA Content Credentials in one line of code

0byte is the managed C2PA signing service for generative AI companies. Managed certificate — none to procure — and a public fingerprint registry, so the proof survives when platforms strip the file.

Built on c2pa-rs · validates in c2patool · RFC 3161 timestamped · Ed25519 + RFC 6962 log
See it survive

Screenshot it. Re-upload it. It still knows.

Manifests get stripped on upload and watermarks wash off. 0byte’s fingerprint is derived from what the image looks like — so the origin survives the trip.

An AI-generated portrait at the moment it is stamped — and the same picture after upload, screenshot, and repost.c2pa
generated1024 × 1024
c2pa
uploaded · re-encodedjpeg q72
screenshotted · cropped77%
reposted640 × 640
manifest signed
fingerprint anchored · #1,204
manifest stripped
fingerprint distance 0
manifest —
fingerprint distance 1
manifest —
fingerprint distance 3

Verified origin — from the last copy alone.

Manifest absent, registry match at distance 3. The record comes back: acme-ai · imagen-x, proof 0b_3f2a8c91.

verified_origin
signature ed25519 ✓ · inclusion proof ✓
leaf #1,204 · root e4b1…9f30
How the C2PA soft binding works
The Problem

Marking AI content is now a legal duty. Keeping the mark alive is the hard part.

The EU AI Act, its Code of Practice, and California's SB 942 all require machine-readable marking and detection. The standard exists — the internet just doesn't preserve it.

how provenance is handled today
An AI-generated image, the front layer of the stack showing how provenance is handled today.
01Image
02Watermark · metadata
03Platform
04Detectors
  1. 01

    The image

    A model generates an image, and it spreads across the open internet.

  2. 02

    Trust is embedded

    A watermark or C2PA manifest is written into the file to record its origin.

  3. 03

    Platforms strip it

    On upload, platforms re-encode the file — and the embedded proof is discarded.

  4. 04

    Detection is a guess

    With only raw pixels left, detectors can estimate the source, never prove it.

The C2PA spec itself calls for a soft binding that lives outside the file. 0byte operates one — openly, for any signer.

Manifests get stripped

C2PA Content Credentials are the right standard — signed, structured, verifiable. But most platforms strip metadata on upload, and the credential leaves with it. That gap is what 0byte closes for C2PA.

Watermarks cover one vendor

Invisible watermarks only mark one company's models and degrade with screenshots and re-encoding. Open-weights models — a huge share of generation — carry no watermark at all.

Detectors are guessing

AI detectors return a probability, not proof, and need retraining every time a new model ships. A guess doesn't hold up in a newsroom, a courtroom, or an audit.

The stakes

The gap is already expensive — and the regulatory clock is running.

38%of popular AI image generators actually ship machine-readable watermarksSource →
$893Min AI-fraud losses reported to the FBI in 2025Source →
Dec 2, 2026EU AI Act compliance deadline for generative AI systems on the market before Aug 2026Source →
Features

C2PA, made survivable.

Standard Content Credentials, signed for you — and a public fingerprint record for the day the file gets stripped. When a format cannot carry a manifest, the record still stands and the response says which binding you got.

stamp.py
# right after your model returns
result = client.stamp(
    image_bytes,
    provider="acme-ai",
    model="imagen-x",
    creator={"name": "Acme Studios"},
)
id 0b_3f2a8c91
binding manifest+registry
claim_generator Acme Studios
signing_key_id k_7c21
verify_url 0byte.tech/proof/0b_3f2a8c91
01 · SDK

One line of code

Stamp right after generation and pass your brand — the credential names you as its claim generator, on our certificate. You get back the credentialed file and a signed proof, and the binding field says exactly what you got, never a silent downgrade.

the image
→
fingerprint · v2
screenshot ✓ distance 1 · re-encode ✓ 0 · crop 77% ✓ 3
02 · Fingerprint

A fingerprint, not a label

Derived from what the image looks like, never embedded in it. Screenshots, re-encodes and crops still match.

#1,204 · newest0b_3f2a8c91
#1,2030b_91be07d4
#1,2020b_c0a55e12
#1,2010b_4d7f2ab9
root_hash e4b1…9f30 · signature ed25519 ✓
03 · Transparency log

A record that can't be rewritten

Every proof lands in an append-only public log with a signed tree head. Added, never edited — not even by us.

verify · free, no accountverified_origin
evidence.manifest absent
evidence.registry match · distance 1
origin_sources [registry]
04 · Verify

One call checks everything

Reads Content Credentials from any signer, matches the fingerprint, and returns a verdict built from evidence — every signal disclosed, never a probability.

proof · 0b_3f2a8c91
provider acme-ai · model imagen-x
timestamp 2026-09-01T14:02:11Z
signature ed25519 ✓ · signing_key_id k_7c21
c2pa
05 · Signed proof

Proofs that can't be faked

Signed with our Ed25519 key the moment it's created — check it against our published keys. A record cannot be forged or backdated.

How It Works

Stamp once. Survive the internet.

The journey every image actually takes — and where the proof comes back.

stamp.py
# right after your model returns
result = client.stamp(
    image_bytes,
    provider="acme-ai",
    model="imagen-x",
)
id 0b_3f2a8c91
binding manifest+registry
verify_url 0byte.tech/proof/0b_3f2a8c91
01

Stamp at generation

One call signs a C2PA manifest into the file — your brand as the claim generator — anchors the derived fingerprint in the public transparency log, and hands back a proof URL anyone can open.

9:41●●●
reposted · 2h
re-encoded on upload
metadata removedc2pa
fingerprint✓ in the registry
02

The internet does its worst

Someone uploads it, the platform strips the metadata, someone else screenshots the upload. The manifest is gone — the fingerprint isn't.

verify · free, no accountverified_origin
content
manifestabsent — stripped
registrymatch
proof0b_3f2a8c91
originacme-ai · imagen-x
evidence, never a probability0byte.tech/verify
03

Verify recovers the proof

Anyone checks the copy, free and without an account. The fingerprint matches the registry, and the original record comes back — who made it, with which model, when.

Use Cases

Built for the people the deadlines apply to.

Whether you generate AI content or have to judge it — the answer comes from the same public record.

AI model providers

Stamp every generation at the source — Content Credentials in the file and a fingerprint in the public log, recording the model, the moment and the brand you declare. Prompts and weights never leave your side.

Newsrooms & media

Check a viral image in seconds — even a screenshot of a re-upload — and read the signed record behind it: who stamped it, with which model, when. Evidence you can publish, not a detector’s guess.

Developer platforms

Add provenance to your product in a single call — across every model you ship, even the open-source ones. No cryptography to learn.

Creators & rights holders

Publish AI-generated work with your brand named in the credential and a signed, timestamped record in the public log — so a repost or a re-encode still resolves to when it was stamped, and by whom.

Why 0byte

C2PA alone, or C2PA that survives.

Content Credentials are the standard. 0byte adds the layer the spec itself calls for — a soft binding that outlives the file — and reads both signals, the manifest and the registry, when you verify.

Works with / extends C2PA

C2PA alone—
WatermarksNo
AI detectorsNo
C2PA + 0byteYes — signs and validates standard manifests

Survives social media upload

C2PA aloneUsually stripped with the metadata
WatermarksMostly
AI detectorsn/a — guesses after the fact
C2PA + 0byteYes — the registry record remains

Survives screenshots & re-encoding

C2PA aloneNo — the file is new
WatermarksMostly — resized crops weakest
AI detectorsn/a
C2PA + 0byteYes — the fingerprint still matches

Covers any AI model, including open-weights

C2PA aloneAny signing provider
WatermarksOnly participating models
AI detectorsUneven on unseen generators
C2PA + 0byteYes — anyone can stamp

Certificate you must procure

C2PA aloneYes — your own signing cert
Watermarksn/a
AI detectorsn/a
C2PA + 0byteNo — signed for you, brand still named

What a match gives you

C2PA aloneSigned claim (when it survives)
WatermarksVendor classifier score
AI detectorsA probability
C2PA + 0byteSigned, logged record: declared provider, model, brand and time

Admits where it fails

C2PA alone—
Watermarks—
AI detectors—
C2PA + 0byteYes — see below
The honest limit

Heavy AI regeneration of content defeats every system on this table — 0byte included. We’re the only column that says so out loud.

Compliance

The rules are in force. The marking has to survive.

The EU AI Act’s transparency obligations apply to generative AI providers. One stamp covers the marking, the detection, and the audit trail.

The deadline

Dec 2, 2026

Compliance deadline for generative AI systems already on the market before August 2026.

Regulation (EU) 2024/1689

01

Machine-readable marking

EU AI Act · Art. 50(2)

Providers of generative AI must mark outputs as artificially generated in a machine-readable format. A stamp embeds standard C2PA Content Credentials declaring AI origin — readable by any validator.

Covered byStamp
02

Detectability

EU AI Act · Art. 50

Markings must be effective and reliable as far as technically feasible — and platforms strip metadata. The registry fingerprint survives screenshots and re-encoding, and verification is free for anyone.

Covered byVerify
03

Auditability

Transparency disclosures

Every proof is anchored in a signed, append-only transparency log. Inclusion and consistency proofs are public and every key we have ever signed with is published, so an auditor recomputes the record rather than trusting 0byte.

Covered byPublic log
Read the EU AI Act compliance mapping
Pricing

C2PA verification is free. Forever.

A provenance registry only works if anyone can check it — so verifying costs nothing, ever. You pay to stamp, by throughput.

Verify

Freeforever

Check any content — no key, no account, no meter.

  • Evidence-first verdicts
  • Manifest + registry signals
  • Transparency-log proofs
Verify content
Free

60req/min

Stamp with Content Credentials from day one.

  • C2PA manifest signing
  • Fingerprint in the public log
  • Brand attribution
Join Waitlist
DevMost teams

300req/min

For pipelines in active development.

  • Everything in Free
  • Higher stamping throughput
  • API key management
Join Waitlist
Pro

1,000req/min

Production volume, compliance-ready.

  • Everything in Dev
  • Priority support
  • Compliance evidence — talk to us
Talk to us

Paid plans finalized at launch — early-access teams lock in launch pricing

FAQs

The questions we get most.

Straight answers — including what 0byte can't do.

Still have a question? Talk to us

0byte is a managed C2PA signing service — the developer platform for C2PA. One call signs a spec-compliant Content Credentials manifest into your file and anchors a derived fingerprint in a public transparency log. Verification is free for anyone: it reads manifests from any signer, matches fingerprints against the registry, and returns a verdict built from that evidence.

C2PA — the Coalition for Content Provenance and Authenticity — is the open standard for content provenance, also known as Content Credentials. A C2PA manifest is a cryptographically signed record embedded in a media file stating who created the content, with which tool or model, and when. Producing one requires an X.509 signing certificate whose chain validators trust; reading one takes a validator like c2patool or Adobe's Inspect tool. C2PA is the marking standard providers reach for when a regulation requires machine-readable disclosure of AI content — and the certificate half is the part 0byte runs for you.

Two ways. Buy an X.509 signing certificate from a certificate authority on the C2PA trust list and build the signing infrastructure around it, or sign through a managed service and skip that entirely. Certificate procurement is the single biggest C2PA adoption pain, and it's the part we run for you: manifests are signed with 0byte's managed credentials while your brand is named as the claim generator, so the credential reads “generated by you.” Bring-your-own-certificate is on the roadmap for teams that want it.

Yes — stamped files carry standard manifests that validate structurally in c2patool and other C2PA-aware tooling. Until 0byte's certificate completes the C2PA Conformance Program, validators note the signer isn't yet on the public trust list; the registry match independently proves origin in the meantime, and we disclose exactly that in our own verification.

Not yet — our signing certificate is going through the C2PA Conformance Program. Until it completes, a validator reads a stamped file's manifest as structurally valid but flags that the signer isn't on the public trust list. In the meantime the registry fingerprint match establishes origin independently, and our own verification reports each signal separately rather than papering over the gap. If you need something to show an auditor today, the transparency log's inclusion proofs are the part that doesn't depend on trust-list status at all. Separately, every manifest is countersigned by an RFC 3161 timestamp authority, which fixes when the signature was made — so a signature stays checkable after the certificate that made it expires or is revoked, and a trust-list decision later still applies to files already published. The same caveat applies there for now: a validator notes the timestamp authority isn't trust-listed either, and we'd rather say that than let you find it in a report. We'll update this answer the day it changes.

Because your manifests don't survive the internet: most platforms strip metadata on upload. 0byte adds the soft binding the C2PA spec calls for — a fingerprint record outside the file — so origin stays recoverable after stripping, plus a free public verifier that satisfies the detection side of the new rules. One API covers marking and detection.

A way of tying provenance to content that lives outside the file. Instead of relying on embedded metadata, a fingerprint is derived from what the content looks like and stored in a registry. A screenshot of a re-encoded copy still looks the same, so its fingerprint still matches — that's how the proof survives when embedded data is gone. It's the C2PA specification's own recovery mechanism; 0byte operates an open one.

Watermarks alter pixels and cover one vendor's models. 0byte changes nothing about how your content looks, works for any model — including open-weights ones no watermark covers — and produces standard C2PA credentials any validator can read. When a C2PA manifest survives, verification reports it alongside the registry match — both signals, one call. We do not read vendor watermarks: SynthID and OpenAI's detectors are not publicly callable, so we do not claim to see them.

Verification says exactly that: no provenance found — no manifest, no registry match. It never converts absence of evidence into a guess about whether something is AI-generated. For teams that want a statistical signal, the API reserves an opt-in estimate (the deprecated /v1/analyze endpoint) — always separate from the verdict, clearly marked as an estimate, and when its model service is paused the response discloses that rather than guessing.

Those rules require machine-readable marking, reliable detection, and auditability. A stamp provides standard machine-readable marking (C2PA), the fingerprint registry keeps it detectable after platforms strip metadata, and the signed transparency log makes the record independently auditable. Whether your specific deployment satisfies a given obligation depends on your system — our docs map each requirement to each feature, and none of it is legal advice.

The fingerprint, who stamped it, the model name, a timestamp, and the digital signature. Never the content itself, never the prompt. The fingerprint is a compact perceptual hash — it mathematically cannot be reversed back into your image. Content sent to verification is checked in memory and never stored.

Verifying content is free forever — no account needed; a public registry only works if checking it costs nothing. Stamping has a free tier (60 calls per minute), with higher-throughput tiers for production. Pricing scales with usage, not seats.

You don't have to trust us — you can check the math. The registry is an append-only Merkle transparency log, the same structure behind Certificate Transparency, which has secured HTTPS for over a decade. Every proof comes with an inclusion proof anyone can verify independently against an Ed25519-signed tree head, and the docs include a complete worked verifier. If anyone — including 0byte — tried to rewrite history, the published roots would stop adding up.

Heavily regenerating content through another AI model defeats any system that works from what content looks like — ours included, and every watermark and detector too. We say this openly because no honest provenance vendor can claim otherwise. That's why verification reports each signal separately with the evidence behind it, instead of pretending a single one is bulletproof.

Images today: PNG, JPEG, WebP, GIF, and TIFF get the full stamp — embedded Content Credentials plus the registry record; BMP and ICO fall back to registry-only, and the response always says which you got. Up to 10 MB per file. Audio and video are on the roadmap, and we won't claim them before they ship. One honest caveat: a small region cut out of a much larger image reads as different content — trimmed edges and screenshots match, cut-out details don't yet.

Make it verifiable. Forever.

Compliance deadline on the calendar? Ship your first stamped, validating image in an afternoon — and verification stays free for everyone.

Start buildingJoin Waitlist

Building something bigger? Compliance questions?

Talk to us