Skip to content

Built on the C2PA open standard

Provable provenance, signed into every pixel.

Krusade embeds tamper-evident Content Credentials in your images and documents with a single API call. No certificate management, no crypto code — verifiable anywhere, from Adobe to c2patool.

Verify a fileHow it works

1,000 free signs — no card required

How it works

From upload to proof in one call

  1. Step 01

    Send us a file

    POST your image or PDF to /api/v1/sign with a bearer key. JPEG, PNG, WebP, AVIF and PDF up to 64 MB — one multipart request, no SDK ceremony required.

  2. Step 02

    We sign and embed

    The signer builds a cryptographically signed, tamper-evident manifest and embeds it invisibly in the bytes you already have — same pixels, provenance included.

  3. Step 03

    Anyone can verify

    Credentials travel inside the file itself. Verify with Krusade, the official c2patool, or Adobe Content Credentials — no vendor lock-in, ever.

Features

Everything a provenance platform should be

One API call

Stripe-for-authenticity developer experience. Bearer key in, signed bytes out. Errors are RFC 7807 problem+json with machine-readable codes.

Tamper-evident by construction

Every manifest is signed with ES256 under Krusade's managed certificate. Any edit breaks the signature chain — and verifiers can tell.

Invisible watermarking

An optional forensic watermark survives screenshots, crops and re-encodes, soft-binding provenance even after the metadata is gone.

Verify anywhere

Standard C2PA manifests, readable by every compliant tool. Your files outlive us — the proof stays in the pixels, not in our database.

Managed trust chain

We run the certificates and keep them chained to the C2PA trust list, so manifests read “Trusted by Krusade”. You never touch a key.

Honest usage pricing

100 free signatures every month, then simple per-sign credits. From side project to production without renegotiating anything.

Developer experience

Sign in the time it takes to brew coffee

One endpoint signs, one verifies, one reports usage. Official SDKs for Go and Python, honest REST for everyone else — and every response is the file itself, not a ticket to redeem later.

  • API keys in one curl flag — no OAuth dance
  • Signed bytes stream straight back to you
  • Verify with any C2PA tool, on or off our platform
sign.shRequest
curl -X POST https://api.krusade.dev/api/v1/sign \
  -H "Authorization: Bearer krsd_live_xxxxx" \
  -F "[email protected]" \
  -F "author=Ada Lovelace" \
  -o sunset-ridge.signed.jpg
main.goGo SDK
client := krusade.New("krsd_live_xxxxx")

result, err := client.Sign(ctx, "photo.jpg",
    krusade.SignOptions{Author: "Jane Doe"})
// photo.jpg.signed — same pixels, provenance included

report, err := client.Verify(ctx, result.OutputPath)
fmt.Println(report.Status) // "valid"
verify-report.jsonResponse
{
  "status": "valid",
  "issuer": "Krusade Signing CA",
  "claim_generator": "krusade/1.0",
  "assertions": [
    "std.exif",
    "std.thumbnail",
    "std.c2pa.actions"
  ]
}

Already holding a signed file?

Upload it to the verifier. Krusade reads the C2PA manifest from the file bytes and returns issuer, timestamp, assertions, and whether the signature chain still holds. Free, no account needed. The file is not stored.

Open the verifier

Pricing

Simple rates, no surprises

Start with 1,000 free signs, add a verified company identity when your team grows, or build a dedicated provenance program with us.

Developer

$0

Start signing with zero friction. First 1,000 signs free.

  • First 1,000 signs free (lifetime)
  • Pay-as-you-go at $0.015/sign after that
  • Krusade shared certificate identity
  • Unlimited public verification
  • Community support
Get started
Most popular

Team

$49/month

Company identity for content credentials — one signing identity across your apps.

  • DNS-verified org domain under Krusade's cert
  • Includes 3 seats (+$15/extra)
  • 5,000 signs/month included
  • Then $0.010/sign via credits
  • IPTC metadata + webhook integrations
  • Invisible watermarking & soft-binding recovery
Start free trial

Enterprise

Custom

Independent org identity hub — BYO cert/DID, API at scale, audit across every pipeline.

  • Bring Your Own Certificate / DIDs (planned)
  • Org-wide signing API & audit trail
  • Multi-ingredient provenance trees
  • Soft-binding & custom retention policies
  • On-premises / Dedicated Cloud
  • SLA guarantees & 24/7 support
Contact us

Full plan details on the pricing page.

FAQ

Questions, answered

What are Content Credentials?

Content Credentials are an open standard (C2PA — Coalition for Content Provenance and Authenticity) for attaching cryptographically signed provenance information to media: who made it, when, how it was edited. Think of it as a tamper-evident nutrition label that lives inside the file itself.

Which file types can I sign?

JPEG, PNG, WebP, AVIF and PDF, up to 64 MB per file. The signed output is byte-identical to the input apart from the embedded manifest — your pixels don't change.

Do I need my own certificate?

No. Krusade signs under its own managed certificate, chained to the C2PA trust list, so manifests read “Trusted by Krusade”. You never handle keys, CSRs, or renewals.

Can someone strip the credentials out?

Removing or editing a signed manifest breaks the signature chain, and any compliant verifier will flag it. For cases where metadata is stripped entirely, Krusade's optional invisible watermark provides a soft binding that survives screenshots and re-encodes.

How do I verify a file?

Anywhere C2PA is supported: our free verifier, the official c2patool CLI, or Adobe Content Credentials. Or programmatically via POST /api/verify — no account needed for public verification.