# What Is zkAPI? Ethereum Launches Private API Payments on Mainnet ![Illustration of Ethereum zkAPI separating blockchain payment identity from private API sessions](hero.png) The Ethereum Foundation and the Open Anonymity Project have launched zkAPI on Ethereum mainnet, turning an earlier zero-knowledge payment design into a working system for paying for AI models and other metered APIs without attaching every request to a conventional billing identity. > **Direct summary:** zkAPI separates the payment relationship from the API session. A user funds a balance through an Ethereum smart contract, then proves that they can pay for usage without revealing which deposit is theirs. The API provider can still see the request itself, while the payment layer can see that valid usage occurred. The system therefore improves payment unlinkability, but it is not a complete anonymity layer for prompts, IP addresses or other network metadata. ## What is zkAPI? zkAPI is a privacy-focused payment layer for metered APIs built around Ethereum and zero-knowledge proofs. Instead of attaching every API request to a permanent customer account or billing identity, a user can fund a balance on Ethereum and later prove that enough credit exists to pay for usage without revealing which specific deposit funded the session. The system is designed primarily to reduce the link between **who funded an API balance** and **which API session spent it**. It does not make the API request itself invisible: the provider processing the request can still see the prompt, response and potentially identifying network metadata. In practical terms, zkAPI aims to let services such as AI inference, blockchain RPC, media generation and machine-to-machine APIs charge for usage without requiring the payment relationship to become a permanent identity layer. ## What happened On October 1, 2026, the Ethereum Foundation announced that zkAPI is live on Ethereum mainnet. The project was built with the Open Anonymity Project and implements a design previously discussed by Ethereum Foundation dAI lead Davide Crapis and Ethereum co-founder Vitalik Buterin. The basic goal is to make metered digital services usable without forcing every request to remain permanently tied to an account, email address, card or other billing identity. The first major use case is AI inference, where users may send highly sensitive prompts to a model provider. The same architecture could also be used for blockchain RPC calls, image and video generation, VPN bandwidth, machine-to-machine services and other APIs that charge according to usage. Instead of paying directly for each request, a user deposits funds into a vault contract on Ethereum. The Ethereum Foundation says the system can work with assets such as ETH or USDC. After the deposit, the balance is represented as a private note. When the user wants to authorize API usage, software running on the user's device creates a zero-knowledge proof showing that a valid balance exists and has not already been spent. The service can verify that proof without being told which specific deposit funded it. ## How zkAPI separates payment from the request The important design choice is that the payment path and the content path are not supposed to contain the same identity information. In the runtime-key flow described by the Ethereum Foundation, the user's local zkAPI client first sends a proof of payment to the zkAPI server. That proof does not contain the prompt. After validating the proof, the server issues a short-lived API key with a limited spending allowance. The key stays on the user's device and can be used directly with the API provider. The API provider therefore sees the prompts and responses because it still performs the computation, but it does not need to know which Ethereum deposit funded that key. When the session ends, the provider records the amount of usage in a signed receipt. The payment layer can then deduct the actual amount from the user's private balance. This lets one authorization cover a session rather than requiring a blockchain transaction for every API call. For readers who want a broader explanation of where the signing authority lives in crypto systems, Terenval's guide to [what a crypto wallet actually stores](/answers/what-is-a-crypto-wallet-and-what-does-it-store/) explains the relationship between keys, credentials and blockchain accounts. ## Why zero-knowledge proofs matter here The privacy mechanism relies on proving that a payment condition is true without revealing all of the information behind it. The Ethereum Foundation describes deposits as commitments in a Merkle tree. A user can prove that a valid note belongs to that set without pointing to the exact deposit. Spending also uses a nullifier, a one-way value derived from the note's secret. The nullifier allows the system to detect an attempt to spend the same balance twice while avoiding a direct disclosure of the note itself. The implementation uses Groth16 proofs on the BN254 curve and Poseidon hashing, while proof verification for API usage is handled off-chain. The broader idea is not to make Ethereum activity invisible. Deposits, withdrawals and contract interactions remain public on-chain. The privacy goal is narrower: breaking the direct link between the on-chain funding event and a particular sequence of API requests. ## Why it matters Most commercial APIs still combine authentication, billing and usage history into the same account. That structure is convenient, but it means a provider can often connect many separate requests over time to the same customer profile. For AI services, the resulting history may contain sensitive questions about work, health, finances, relationships or private projects. zkAPI is an attempt to separate two things that are usually bundled together: proving that a user can pay and identifying who the user is. That distinction could become increasingly relevant as AI agents begin paying for digital services automatically. A machine may need to purchase inference, data, storage or other API calls without maintaining a conventional account for every provider. The project also shows another practical use of Ethereum beyond asset transfers and DeFi: Ethereum can act as a settlement and ownership layer while most high-frequency activity takes place off-chain. ## What crypto users should know zkAPI should not be interpreted as complete anonymity. The Ethereum Foundation explicitly notes that the API provider still sees the contents of the requests it processes. If a prompt contains a person's name, company, location, writing style, previous conversation history or other identifying details, that information can still reveal or strongly suggest who the user is. Network metadata is another limitation. A provider or gateway may still see an IP address and may be able to correlate sessions through timing or traffic patterns. The system primarily addresses the billing link: it is designed to make it harder to connect a particular API session to the Ethereum deposit that paid for it. Users also still need to interact with Ethereum to fund or recover their balance. That means ordinary wallet-security rules continue to matter. If a user controls the wallet that makes the deposit, they remain responsible for protecting the keys or recovery material associated with that wallet. Terenval's explanation of [custodial vs. non-custodial wallets](/answers/custodial-vs-non-custodial-wallets/) provides useful context for understanding that responsibility. ## Potential impact on wallets and Ethereum infrastructure zkAPI does not require crypto wallets to become AI applications, but the model creates a natural integration point for wallets. A wallet could eventually help a user fund a zkAPI vault, review the contract interaction, approve a deposit and manage the on-chain part of the workflow while the local zkAPI client handles private usage credentials. For non-custodial wallets, that would fit an existing pattern: the wallet remains responsible for user-authorized signing, while a separate application handles the service-specific logic. The approach may also increase demand for wallet interfaces that make contract deposits and approvals understandable to ordinary users. Privacy technology becomes much less useful if users cannot tell what they are signing or which contract controls their funds. The Ethereum infrastructure side may benefit as well. zkAPI demonstrates a model where Ethereum provides settlement, withdrawal guarantees and public verification, while the frequent API interactions do not each require an on-chain transaction. That reduces the need to put every small payment directly on the blockchain while still keeping the user's funds anchored to a smart contract. ## What the launch does not prove yet A mainnet launch shows that the protocol can run with real contracts and real funds, but it does not by itself establish large-scale adoption. API providers still need to integrate the model, users need compatible software, and the privacy properties need to be evaluated under real-world traffic patterns. There are also practical questions around proving performance, user experience, liquidity, compliance and how service providers will handle abuse or disputes without reintroducing persistent identity. The project is open source, which makes those questions easier for outside developers and researchers to examine. ## What happens next The most important signal to watch is whether independent API providers begin supporting zkAPI-style payments. AI inference is the first obvious market because prompts are sensitive and usage is naturally metered, but the Ethereum Foundation also points to RPC services, media generation, VPNs and machine-to-machine payments as possible applications. If adoption grows, zkAPI could become an example of a broader pattern in crypto infrastructure: blockchain settlement underneath, privacy-preserving authorization in the middle, and ordinary web APIs on top. For now, the main development is straightforward: a zero-knowledge API payment design that was previously a research proposal is now running on Ethereum mainnet. ## Editorial and technical review - Published by: Terenval - Technical review: Terenval Wallet team - Last reviewed: 2026-10-04 ## Sources - [Ethereum Foundation: Introducing zkAPI — private usage credits for any API](https://blog.ethereum.org/2026/10/01/introducing-zkapi) - [Ethereum zkAPI GitHub repository](https://github.com/ethereum/zkapi) - [Ethereum Research: ZK API Usage Credits — LLMs and Beyond](https://ethresear.ch/t/zk-api-usage-credits-llms-and-beyond/24104) - [The Block: Ethereum Foundation launches zkAPI](https://www.theblock.co/news/defi/2026-10-01-ethereum-foundation-launches-zkapi-417504) Official article: https://wallet.terenval.com/news/what-is-zkapi-ethereum-private-api-payments-mainnet/ [Machine-oriented Terenval index](https://wallet.terenval.com/llms.txt)