zkAPI Ethereum Mainnet: How Private API Payments Actually Work
zkAPI is now live on Ethereum mainnet, separating API payments from user identity with zero-knowledge proofs while keeping AI prompts and billing flows in different layers.
On this page
zkAPI Ethereum mainnet deployment went live on October 1, giving developers a working way to separate API payments from the identity normally attached to an API key. Built by the Ethereum Foundation with the Open Anonymity Project, zkAPI lets a user deposit credits into an Ethereum vault and later prove that a private balance can pay for API usage without revealing which deposit funded the request. The first target is AI inference, but the same mechanism is designed for any metered service.
zkAPI Ethereum mainnet turns a research design into working software
The idea did not begin with the October launch. In February 2026, Ethereum Foundation researcher Davide Crapis and Vitalik Buterin published a design called ZK API Usage Credits that proposed depositing funds once and making repeated API calls without linking every request to the same payment identity. The problem was straightforward: ordinary API credentials connect requests to an account, while paying separately on a blockchain for every request introduces cost, latency and a visible transaction trail. The new zkAPI implementation takes that research direction and packages it into a client, server and smart-contract system running on Ethereum mainnet.
That distinction matters because zkAPI is not another token or a new blockchain network. Ethereum acts as the settlement layer where deposits and withdrawals are recorded, while most API authorization happens away from the chain. A user therefore does not need to create an Ethereum transaction for every model request. The practical change is that a blockchain deposit can become a private spending balance for many later API requests.
The key change is separating payment from the API request
Normally, an API provider needs to know which account is making a request so it can authenticate the caller and charge that account. zkAPI changes that relationship by representing deposited funds as a private note, which is a cryptographic record of spending rights rather than an ordinary account balance exposed to the service. Software on the user's device creates a zero-knowledge proof, meaning it proves a statement is true without revealing the underlying secret information. The proof tells the payment server that a valid balance can cover the requested spending without identifying the particular deposit behind it.
The system then creates a short-lived API key with a spending limit. In the prompt-private mode, that key can be sent directly from the user's device to the AI provider, while the payment server handles authorization and later settlement. The provider receives the request and can process it normally, but it does not receive the identity of the Ethereum deposit that funded the session. This is the central separation: the payment system verifies that money exists, while the service system handles the actual request.
A nullifier prevents the same private balance being spent twice
Privacy alone would not make a payment system useful if a user could prove the same balance repeatedly. zkAPI addresses that with a nullifier, a one-way value derived from the private spending state that acts like a cryptographic serial number. When a valid balance is spent, its corresponding nullifier is recorded so another proof cannot legitimately spend the same state again. A duplicate nullifier therefore exposes an attempted double spend without revealing the original deposit or the user's identity.
The underlying implementation uses a Merkle tree, which is a cryptographic structure that lets the system prove membership in a large set without revealing the specific entry being referenced. The current protocol documentation describes a 32-level active-note Merkle tree, Groth16 zero-knowledge proofs over the BN254 curve, Poseidon hashing and Baby-JubJub commitments. These details are not merely implementation trivia: they define the cryptographic assumptions and compatibility requirements of the current protocol version.
One authorization can cover a session instead of every request
The system is designed around bounded usage rather than an onchain payment for each API call. A client proves that its private balance can support a capped session, and the server issues a temporary key with that spending ceiling. When the key expires, the provider's measured usage is represented through a signed usage receipt and the payment layer settles the actual amount against the private balance. That means the user can make multiple API requests during a session without producing a new blockchain transaction for each one.
This is especially relevant to AI applications because the cost of individual requests can vary considerably. A short question and a long reasoning task may consume very different amounts of model resources, so a simple one-payment-per-request system would either require frequent authorization or reserve more money than is ultimately used. zkAPI instead separates the authorization limit from the final metered charge. The trade-off is more protocol complexity, but it avoids turning every AI interaction into an onchain settlement event.
The privacy boundary is narrower than βanonymous AIβ suggests
zkAPI deliberately does not claim to hide everything about an AI session. The payment layer can avoid learning which deposit funded a request, but the AI provider still sees the prompt and response because it has to run the model. The provider can also see network information such as an IP address and may be able to correlate sessions through timing or repeated identifying details in prompts. The project's own documentation therefore describes payment unlinkability rather than complete network or content anonymity.
Prompt content can create another source of correlation. Someone who repeatedly supplies the same personal information, writing style, project files or conversation history may remain recognizable to the provider even when the payment records are separated. This limitation was already visible during discussion of the February research design, where researchers raised the possibility that inference characteristics and request patterns could undermine unlinkability even when the cryptographic payment mechanism works correctly. The October implementation does not remove that problem; it addresses the billing relationship specifically.
The implementation has two different traffic paths
zkAPI currently supports a simpler proxy arrangement as well as the more privacy-preserving runtime-key approach. In proxy mode, the zkAPI server relays the request to the upstream service, which makes deployment easier but means the relay can see the traffic. In the prompt-private arrangement, the temporary provider key is used directly by the client so the payment intermediary does not receive the prompt or response. The distinction is significant because choosing the easier deployment mode changes the privacy properties of the system.
| Component | What it handles | What it can still see |
|---|---|---|
| Ethereum | Deposits, closures and withdrawals | Public blockchain activity |
| zkAPI server | Proof verification and usage settlement | Payment-related session information |
| AI provider | Prompts, responses and model execution | Request content and network metadata |
| Local client | Private notes, proofs and runtime keys | User-controlled local state |
The table shows why calling the system simply βprivate AIβ would be misleading. Each layer has a different visibility boundary, and the privacy property depends on keeping those boundaries separate. The cryptographic payment mechanism protects the relationship between a deposit and API usage; it does not magically conceal everything happening at the network or model layer. That narrower claim is also easier to test because developers can inspect which component receives each piece of information.
The first practical target is AI, but the protocol is broader
The Ethereum Foundation lists AI chat and agents as the initial use case because model calls are naturally metered and often involve sensitive information. But the same payment pattern can apply to blockchain remote procedure call services, image generation, video generation, bandwidth services and machine-to-machine APIs. A blockchain remote procedure call, or RPC, is a request sent to infrastructure that provides blockchain data or submits blockchain operations. For autonomous software, the interesting part is that a service can potentially accept prepaid cryptographic authorization without maintaining a conventional customer account for every machine making requests.
The project already exposes familiar interfaces for developers rather than requiring every application to adopt a completely new API format. Its client supports OpenAI-compatible and Ollama-compatible interfaces, allowing existing local tools to communicate through the zkAPI client. The Open Anonymity repository also documents a local daemon, browser software development kit and contract components for the current implementation. That makes the project more concrete than a protocol specification alone, although the repository still describes the software as experimental.
There are still open engineering questions around the live implementation
The mainnet launch does not mean every operational issue has disappeared. The public repository already shows active development and open issues, including one reported on October 2 involving a request-key limit and another concerning third-party funding of a private note. The repository also documents setup and deployment requirements that developers need to understand before treating the system as a drop-in payment service. In other words, the software is live, but the implementation is still evolving.
There is also an important distinction between privacy of the payment trail and privacy of the initial funding transaction. Ethereum records the deposit itself publicly, even though the later private note is designed to break the direct link between a payment authorization and a particular deposit. Researchers discussing the original design pointed out that timing between a public deposit and subsequent use can create correlation information. That means the complete privacy story depends on how funds enter and leave the system, not just how individual API requests are authorized.
What developers should watch as zkAPI moves beyond the launch
The next useful evidence will come from actual deployments rather than another description of the cryptography. Developers need to see how providers integrate proof-based billing, how runtime keys behave under failures, how usage receipts are reconciled, and how much operational overhead the system adds compared with ordinary API accounts. The current documentation also identifies the cryptographic construction and setup requirements, giving developers specific components to audit rather than treating βzero knowledgeβ as a blanket security guarantee.
For now, zkAPI is best understood as a new payment primitive for metered digital services: fund once on Ethereum, prove spending rights privately, use a bounded session, then settle the measured usage. Its most interesting property is not that an AI model suddenly becomes anonymous, but that billing identity no longer has to travel with every API request. Whether that separation becomes useful beyond privacy-focused experiments will depend on providers adopting the protocol and developers testing its operational costs, failure modes and privacy boundaries in real services.
Share this post



