Quickstart

Get from zero to a verified ZK proof in four steps. No cryptography knowledge required.

curl -X POST https://api.tinyzkp.com/prove/template/range_proof \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{"params":{"min":0,"max":100,"witness_steps":[42,44]}}'

// Save the job_id — you'll need it next
{"job_id":"prf_a1b2c3","status":"proving","eta_ms":1200}

curl https://api.tinyzkp.com/prove/prf_a1b2c3 \
  -H "Authorization: Bearer tzk_..."

{"status":"completed","proof":{"version":4,"bytes":"0x6a8f...","size_kb":12.4}}

curl -X POST https://api.tinyzkp.com/verify \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{"proof":{"version":4,"bytes":"0x6a8f...","size_kb":12.4}}'

// The verifier confirmed the proof without learning your secret
{"valid":true,"verified_in_ms":2.8}

Common errors

Client-Side Verification

Verify proofs entirely client-side with the @tinyzkp/verify WASM package. No server roundtrip, no API key required for verification.

npm install @tinyzkp/verify

Browser

import init, { verify } from '@tinyzkp/verify';

await init();  // load WASM binary (~785 KB)

const result = verify({ version: 4, bytes: proofBytes });
console.log(result.ok);     // true
console.log(result.version); // 4

Node.js

const { verify_json } = require('@tinyzkp/verify');

const result = verify_json(JSON.stringify(proofObject));
console.log(result.ok); // true

• Offline verification — no network request, no API key needed
• Edge-compatible — runs in Cloudflare Workers, Deno, Vercel Edge Functions
• ~785 KB WASM binary (gzips to ~300 KB)
• Returns { ok: bool, error?: string, version?: number }

Authentication

All endpoints (including /verify) require a Bearer token in the Authorization header:

Authorization: Bearer tzk_...

• Your API key is delivered via email after signing up.
• The /verify endpoint is free (no charge) but requires your API key to prevent abuse.
• Keep your API key secret. Do not expose it in client-side code or public repositories.

Key Rotation

Rotate your API key at any time. Your old key is immediately invalidated and a new key is returned. Limited to once per 24 hours.

curl -X POST https://api.tinyzkp.com/api/rotate-key \
  -H "Authorization: Bearer tzk_YOUR_CURRENT_KEY"

Response:

{
  "api_key": "tzk_NEW_KEY_HERE...",
  "prefix": "tzk_a3b2...",
  "message": "Key rotated successfully. Your old key is now invalid."
}

API Endpoints

All endpoints are served from https://api.tinyzkp.com.

Proof Templates

TinyZKP ships with six proof templates that cover common zero-knowledge use cases. Templates handle all the cryptographic complexity — you just provide your data. Use POST /prove/template/:id to prove, or browse templates with GET /templates.

Template Examples

Each template below is a complete, copy-paste working example. Replace tzk_... with your API key and run.

The Python and TypeScript snippets use the official TinyZKP HTTP-API client SDKs. Install once, then any subsequent example just works:

pip install tinyzkp        # Python (PyPI)
npm install tinyzkp         # TypeScript / JS (npm, ESM + CJS)
cargo add tinyzkp           # Rust (Cargo)

range_proof — prove a value is in [min, max]

Proves an integer V satisfies min ≤ V ≤ max without revealing V. Encode (V - min) as additive witness_steps. Example: prove a balance is between $0 and $10,000 by encoding the actual value $4,237 as [2000, 2237] (or any decomposition that sums to 4,237).

curl -X POST https://api.tinyzkp.com/prove/template/range_proof \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{"params":{"min":0,"max":10000,"witness_steps":[2000,2237]}}'

from tinyzkp import TinyZKPSync
with TinyZKPSync("https://api.tinyzkp.com", api_key="tzk_...") as c:
    job = c.prove_template("range_proof", params={"min":0,"max":10000,"witness_steps":[2000,2237]})
    proof = c.wait_for_proof(job)
    assert c.verify(proof).ok

import { TinyZKP } from "tinyzkp";
const c = new TinyZKP("https://api.tinyzkp.com", { apiKey: "tzk_..." });
const job = await c.proveTemplate("range_proof", { min:0, max:10000, witness_steps:[2000,2237] });
const proof = await c.waitForProof(job);
console.log((await c.verify(proof)).ok);  // true

hash_preimage — prove knowledge of a secret behind a hash

Proves you know a preimage whose iterative arithmetic hash equals a public digest. The preimage stays hidden when ZK is enabled. Use for password attestations and commitment opening.

curl -X POST https://api.tinyzkp.com/prove/template/hash_preimage \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{"params":{"digest":12,"preimage_steps":[7,3,2]},"zk":true}'

job = c.prove_template("hash_preimage",
    params={"digest":12, "preimage_steps":[7,3,2]}, zk=True)

computation_attestation — prove f(secret) = public_output

Proves that applying a secret sequence of additive steps produces a public output. The steps stay hidden; only the output is revealed. Use for ML inference receipts or attesting an agent did the work it claims.

curl -X POST https://api.tinyzkp.com/prove/template/computation_attestation \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{"params":{"steps":[3,5,7,11],"expected_output":26}}'

job = c.prove_template("computation_attestation",
    params={"steps":[3,5,7,11], "expected_output":26})

accumulator_step — prove a chain of state transitions

Proves that applying a sequence of additive deltas to initial reaches final. Use for balance updates, ledger reconciliation, or rollup transition attestation.

curl -X POST https://api.tinyzkp.com/prove/template/accumulator_step \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{"params":{"initial":1000,"final":1450,"deltas":[100,200,150]}}'

job = c.prove_template("accumulator_step",
    params={"initial":1000, "final":1450, "deltas":[100,200,150]})

policy_compliance — prove cumulative actions stayed under a threshold

Proves that sum(actions) ≤ threshold without revealing individual actions. Classic agent receipt: prove the agent's spending stayed under a daily cap, or its requests stayed under a rate limit, without exposing each transaction.

curl -X POST https://api.tinyzkp.com/prove/template/policy_compliance \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{"params":{"actions":[150,200,75,300,180],"threshold":1000},"zk":true}'

job = c.prove_template("policy_compliance",
    params={"actions":[150,200,75,300,180], "threshold":1000}, zk=True)

data_integrity — prove a dataset matches a committed checksum

Proves that sum(elements) == checksum. Use for dataset audits, ledger balance attestation, or proving a batch of records is complete.

curl -X POST https://api.tinyzkp.com/prove/template/data_integrity \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{"params":{"elements":[100,250,75,500,125],"checksum":1050}}'

job = c.prove_template("data_integrity",
    params={"elements":[100,250,75,500,125], "checksum":1050})

Plan Tiers

Rate limits, concurrency, and per-proof discounts vary by plan. All plans include free verification. Self-serve signup ships Free, Developer, and Scale directly. Team is documented here for completeness because the per-proof rate sheet supports it — provisioned via contact as a custom contract.

Per-Proof Pricing

Pay per proof based on trace complexity. Team and Scale plans receive automatic discounts on every proof. These rates are 10–40x lower than running traditional provers, thanks to our O(√N) memory architecture (where N is the number of computation steps).

Verification is always free

Parameters

Security Parameters

These parameters control the cryptographic strength of your proof.

Performance Parameters

These parameters control trace layout and proving speed.

Zero-Knowledge Mode

By default, TinyZKP proofs prove that a computation is correct, but the proof structure reveals information about the trace. To hide the computation entirely, enable zero-knowledge masking by setting zk_mask_degree in your prove request.

curl -X POST https://api.tinyzkp.com/prove/template/range_proof \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "params": {"min": 0, "max": 100, "witness_steps": [42, 44]},
    "zk_mask_degree": 1
  }'

• zk_mask_degree: 0 (default) — standard proof, no zero-knowledge masking
• zk_mask_degree: 1 or higher — ZK-masked proof (protocol v4). The verifier learns nothing except that the statement is true.
• When using templates, you can also pass "zk": true as a shorthand for "zk_mask_degree": 1.
• ZK masking adds minimal overhead. Proofs are slightly larger but verification time is unchanged.

Cost Estimation

Estimate cost, proving time, and proof size before generating a proof. This endpoint is public — no authentication required.

# Estimate cost for a range proof
curl -X POST https://api.tinyzkp.com/estimate \
  -H "Content-Type: application/json" \
  -d '{
    "template_id": "range_proof",
    "params": {"min": 0, "max": 100, "witness_steps": [42, 44]}
  }'

Response:

{
  "estimated_trace_length": 128,
  "tier": "Tiny",
  "estimated_cost_cents": 5,
  "estimated_time_ms": { "min": 50, "max": 200 },
  "estimated_proof_size_bytes": { "min": 7000, "max": 15000 }
}

• No auth required — use this to preview costs without an API key.
• You can also estimate by program length: {"program_length": 500}.
• The tier field maps to the pricing tiers (Tiny, Standard, Large, Enterprise, XL).

Batch Proving

Submit 1–100 prove jobs in a single request. Each job is billed individually by trace length.

curl -X POST https://api.tinyzkp.com/prove/batch \
  -H "Authorization: Bearer tzk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "requests": [
      {"workload_id": "range_proof", "params": {"min": 0, "max": 100, "witness_steps": [20, 22]}},
      {"workload_id": "range_proof", "params": {"min": 0, "max": 50, "witness_steps": [10, 12]}},
      {"workload_id": "data_integrity", "params": {"elements": [1, 2, 3], "checksum": 6}}
    ]
  }'

Response:

{
  "job_ids": ["a1b2c3...", "d4e5f6...", "g7h8i9..."]
}

• Job IDs are returned in the same order as the requests.
• Atomic rate limiting — if the batch would exceed your RPM quota, the entire batch is rejected (no partial submission).
• Maximum batch size: 100 requests.
• Poll each job individually via GET /prove/:job_id.

Proof Inspection

Get a detailed breakdown of a completed proof, including trace metadata, commitment digests, and verification timing.

curl https://api.tinyzkp.com/prove/JOB_ID/inspect \
  -H "Authorization: Bearer tzk_..."

Response:

{
  "trace_commitment_digest": "a1b2c3d4...",
  "initial_acc": 0,
  "final_acc": 42,
  "trace_length": 128,
  "query_commitments": {
    "trace_commitment": "a1b2c3d4...",
    "composition_commitment": "e5f6a7b8...",
    "fri_commitment": ""
  },
  "commitment_scheme": "STARK",
  "version": 4,
  "verify_time_ms": 3
}

• The proof must be completed before inspection is available (returns 409 if still proving).
• commitment_scheme is "STARK" for standard proofs or "KZG" for recursively aggregated proofs.
• verify_time_ms is the server-side verification time, useful for benchmarking.

EVM Calldata

Extract ABI-encoded calldata for on-chain verification. Use this to submit proofs to a Solidity verifier contract.

curl https://api.tinyzkp.com/proof/JOB_ID/calldata \
  -H "Authorization: Bearer tzk_..."

Response:

{
  "calldata": "0x6a8f3b2c...",
  "size_bytes": 1248
}

Workflow:

1. Generate a proof via POST /prove/template/:id
2. Wait for completion via GET /prove/:job_id
3. Retrieve calldata via GET /proof/:job_id/calldata
4. Submit the calldata to a Solidity verifier contract on-chain

• The calldata is ABI-encoded and ready to submit directly to the verifier contract’s verify() function.
• Note the path: /proof/:job_id/calldata (not /prove/).

On-Chain Verification (Solidity)

The StarkVerifier contract verifies proofs on-chain using recursive KZG verification via the BN254 pairing precompile (~300K gas). The contract is open source at contracts/StarkVerifier.sol.

const verifier = new ethers.Contract(VERIFIER_ADDRESS, [
  "function verifyRecursiveProof(bytes calldata) view returns (bool)"
], provider);

// Get calldata from TinyZKP API
const { calldata } = await fetch(`https://api.tinyzkp.com/proof/${jobId}/calldata`, {
  headers: { Authorization: `Bearer ${apiKey}` }
}).then(r => r.json());

// Verify on-chain
const valid = await verifier.verifyRecursiveProof(calldata);
console.log("On-chain verified:", valid); // true

• ~300K gas per verification via recursive KZG/Halo2 wrapping
• Accepts 3 public inputs: initial_acc, final_acc, trace_length
• The contract interface is at IHcStarkVerifier.sol

MCP Integration

TinyZKP ships as an MCP server so AI agents can generate and verify proofs natively.

Install

Download the hc-mcp binary from the GitHub releases page, or build from source:

cargo install --path crates/hc-mcp

Configure

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "tinyzkp": {
      "command": "hc-mcp",
      "args": ["--api-key", "tzk_..."]
    }
  }
}

Available MCP Tools

Remote Access (HTTP)

Connect to TinyZKP’s MCP server remotely — no binary installation required:

claude mcp add --transport http tinyzkp https://mcp.tinyzkp.com

# Run the HTTP MCP server locally
HC_MCP_HTTP_PORT=3001 cargo run -p hc-mcp --bin hc-mcp-http

# Connect Claude Code to your local server
claude mcp add --transport http tinyzkp http://localhost:3001/mcp

• The hosted server at https://mcp.tinyzkp.com requires your TinyZKP API key
• Supports both SSE streaming and JSON responses
• Works with any MCP-compatible client (Claude Code, Cursor, VS Code, etc.)

Glossary

Key terms used throughout this documentation, explained in plain English.

Interactive API Reference

Explore the full API interactively with our Swagger UI. Try endpoints directly from your browser.

Open Swagger UI →