Testnet
Back to Blog

March 5, 2026

Verifying ZK Proofs with x402 Using Kurier

Learn how to verify ZK proofs with x402 using Kurier. Turn proof verification into a simple API call connected to zkVerify's shared verification backbone.

Verifying ZK Proofs with x402 Using Kurier

AI agents are starting to act.

They run code. They call APIs. They coordinate with other agents. They move assets.

But here's the problem:

They can generate output. They cannot prove it's correct.

If agents are going to transact with each other or operate on behalf of users, verification cannot be optional. It has to be built in.

This is where zero-knowledge proofs come in. And this is where Kurier fits.

Kurier turns proof verification into a simple API call. It connects your agent to zkVerify's shared verification backbone, so you don't have to run your own verifier infrastructure.

This guide walks through verifying ZK proofs with x402 using Kurier, with real examples.

The Problem: Verification Is Not an Agent Feature

Let's say your agent:

  • Runs a zkVM
  • Executes a deterministic workflow
  • Generates a proof that the computation was correct

Now what? Today, most teams would need to:

  • Handle proof formats like Groth16, Plonk, or STARK
  • Maintain verifier contracts or services
  • Monitor uptime
  • Handle retries and edge cases
  • Scale verification volume
  • Parse verification results correctly

That is infrastructure work. Agent builders want to:

  • Run a model
  • Generate a proof
  • Verify it
  • Continue execution

Verification should not change your architecture at scale. 5,000 proofs per day and 50,000 proofs per day should feel the same.

Kurier makes that possible.

What Kurier Does

Kurier is the API layer for proof verification.

Your agent submits a proof → Kurier routes it to zkVerify → You get back a deterministic verification result

No custom verifier stack. No on-call rotation. No protocol-specific sprawl.

One endpoint. Production-ready.

Verifying ZK Proofs with x402 Using Kurier

Let's walk through a practical flow.

Step 1: Generate the Proof

Your agent runs a zkVM and produces:

  • A proof
  • Public inputs
  • Metadata about the proof system
{
  "proofType": "groth16",
  "proof": { "...": "..." },
  "publicInputs": ["123", "456"]
}

At this point, your agent has cryptographic evidence. Now it needs verification.

Step 2: Submit the Proof via Kurier

Using x402-compatible schema, your agent sends the proof to Kurier.

curl -X POST https://api.kurier.xyz/verify \
  -H "Content-Type: application/json" \
  -d '{
    "proofType": "groth16",
    "proof": {...},
    "publicInputs": ["123","456"]
  }'

Response:

{
  "verificationId": "0xabc123",
  "status": "verified",
  "timestamp": "1721020301"
}

That's it.

Behind the scenes:

  • Kurier routes the request
  • zkVerify handles the verification
  • The result is recorded and returned

Your agent receives a clear, machine-readable result and continues execution.

Supported Proof Systems

Kurier supports multiple proof systems without forcing you to manage separate verifiers.

Examples include:

  • Groth16 verification via Kurier
  • Plonk verification via Kurier
  • STARK verification via Kurier
  • RISC Zero proof submission using Kurier

Multi-proof reality is already here. Kurier reduces verifier sprawl into one API.

Making Kurier Discoverable to AI Agents

AI agents increasingly discover services through structured schemas, skill indexes, and tool registries.

Kurier is built to integrate cleanly into these environments.

That means:

  • x402-compatible schemas
  • Structured endpoints
  • Clear machine-readable responses
  • MCP-compatible service exposure

An agent that supports skills or tool discovery can:

  • Find Kurier
  • Understand its verification capability
  • Call it directly
  • Integrate without manual wiring

In other words, your customers might not be humans. They might be agents.

Kurier is ready for both.

Real Agent Use Cases

Here's where this gets practical.

Agent-to-Agent Verification

Two agents negotiate → One produces a proof of computation → The other verifies via Kurier before accepting the result.

No trust assumptions. Just math.

zkVM Policy Execution

An agent runs a policy engine inside a zkVM → It proves the policy was executed correctly → Kurier verifies the proof before the action is finalized.

Verifiable AI Output

As local models run on capable machines, proof generation becomes feasible.

Agents can:

  • Prove a computation
  • Prove a transformation
  • Prove a compliance check

Kurier verifies it at scale.

Why This Matters Now

We are seeing:

  • More open source agents
  • More local models
  • More zkVM adoption
  • More autonomous workflows

As proof generation increases, verification demand rises with it.

But most teams should not build and operate verification infrastructure themselves.

Proof verification is infrastructure.

Kurier turns it into a simple API call.

Scale does not change your architecture. Reliability does not depend on your own ops stack.

You plug in. You verify. You ship.

Architecture Overview

The flow looks like this:

Agent → zkVM → Proof generated → Kurier API → zkVerify verification backbone → Verification result returned → Agent continues execution

Clean. Deterministic. Production-ready.

Final Takeaway

AI agents are moving from generating output to making decisions.

Decisions require verification.

Kurier is the API layer that connects agents to zkVerify's shared verification backbone.

You focus on building your agent. We handle verification.