TinyZKP

What is TinyZKP?

TinyZKP mints a tamper-evident zero-knowledge proof that a state-transition chain is consistent — start at X, apply these steps, provably reach Y — so an agent or API caller can hand over a verifiable receipt instead of requiring trust. It provides transparent, post-quantum STARK-style proofs with an O(√T) prover-memory architecture, no trusted setup, and verification in milliseconds. It serves developers, AI agents, and API users who need verifiable state-transition receipts.

How to use TinyZKP?

Install the MCP server for AI agents (Claude, GPT, Cursor) via claude mcp add --transport http tinyzkp https://mcp.tinyzp.com, then call its proof tools as native function calls. Alternatively, use the terminal CLI via npx @tinyzp/cli or the plain HTTP API at https://api.tinyzzp.com with an API key from tinyzzp.com/signup. Verification is always free and works in the browser via the WASM package @tinyzzp/verify.

Key features of TinyZKP

• O(√T) prover memory vs standard STARK O(T) — ≈4,096× reduction measured
• Verification in polylog time, always free
• Transparent (no trusted setup) and post-quantum (hash-based)
• SDKs for Python, TypeScript, and Rust
• MCP server for native AI agent integration (Claude, GPT, Cursor)
• Browser WASM verifier with no server or API key required

Use cases of TinyZKP

• State machine attestation: prove a sequence of state transitions without revealing intermediate values
• Audit-log checkpoints: generate a tamper-evident receipt that a log transitioned from one hash to another through a series of entries
• AI agent verifiable receipts: an agent hands over a proof that its chain-of-thought or action sequence reached a stated outcome
• API state transition proofs: two systems prove they agree on a sequence of values without exposing the data itself

FAQ from TinyZKP

What does TinyZKP prove that other schemes don't?

TinyZKP proves state-transition chain consistency with a transparent (no trusted setup) STARK that uses an O(√T) prover-memory architecture, unlike standard STARKs which require O(T) memory. This makes long traces practical without reserving high-RAM servers.

What are the runtime dependencies?

The CLI requires Node 18+ ESM. The Python SDK works with Python 3 and pip install tinyzkp. The TypeScript SDK ships a dual ESM+CJS build for Node 18+, bundlers, and edge runtimes. The WASM verifier works in any modern browser.

Where does proof data live?

Proving jobs are submitted to the hosted API at api.tinyzp.com; job and proof data reside on TinyZKP's servers during the lifecycle. Verification can be done client-side via the WASM verifier without sending proof data to any server.

What transports and authentication are available?

The MCP endpoint supports HTTP transport and is publicly rate-limited (no API key required). The full HTTP API uses HTTPS with bearer token authentication (API key tzk_...). The WASM verifier and CLI can verify proofs locally with no network call.

What are the known limits?

Free tier: 100 proofs per month, 1 in‑flight job, 10 RPM, $5/mo cap. Developer plan: 4 in‑flight, 100 RPM, $500/mo cap. Proofs under 10K trace steps cost $0.05/proof; longer traces cost more per step. Verification is always free and unlimited.