openzk
Menu

Private payments for machine commerce

Cash for the
machine internet.

Software moves at the speed of a request.
Now, money can too. Fund once. Spend by proof.

Enter openzk Explore the protocol
01 / Cash, reimagined Scroll to discoverOne request. One proof.
01 / The protocolBuilt for a different internet

APIs are becoming markets.
Machines need cash.

Software can reason, create, and transact. Paying for it still assumes a human account.

openzk replaces that ceremony with a private note. A bearer instrument for the machine internet.

01

Accounts

An identity before a transaction. Registration before a request.

02

Credentials

A reusable key that ties access, billing, and attribution together.

03

History

Every payment adds another entry to a permanent purchase trail.

Public at the edges. Private in the middle.

ETH → Note → Proof → ETH

Fund once.
Spend by proof.

Two public settlement endpoints connected by a thin proof beam through a hidden dark center.
Deposit / PublicHidden stateWithdraw / Public
01

Fund a note.

Deposit ETH into the Ethereum vault. The deposit is public; the note stays in your browser.

02

Pay by proof.

Prove a valid payment to a service. Your identity, balance, and other purchases remain hidden.

03

Exit to Ethereum.

Withdraw your remaining funds. Public settlement, with a contract escape path when needed.

02 / The privacyLess information. More possibility.

What the service learns

Exactly
one thing.

Valid payment

Proof that you paid.
Everything else stays yours.

Private stateOne valid payment
Identity

Not requested.

Balance

Not revealed.

Purchase history

Not shared.

Precision, down to the request

Small payments.
Infinite possibility.

A private note becomes a series of precise payments. One request. One proof. One valid payment.

Inference / 001$0.0032
Inference / 002$0.0018
Inference / 003$0.0041

Illustrative per-call prices

One request / One proofPayment verified
03 / The possibilitiesMachine-native by design

Built for agents

Software can pay
for software.

A request should need a payment, not a personality. Give software the ability to pay for what it uses.

Try the playground
Example / Metered inferenceHTTP
01agent.request()Request
02service.quote()Quote
03openzk.prove(payment)Prove
04200 OKAccepted ↗

Payment verified. Identity not requested.

Requirement metBalance stays hidden

Privacy with assurance

Prove enough.
Reveal nothing more.

Show that your balance meets a requirement without disclosing the balance itself. Private does not mean unverifiable.

Balance ≥ Requirement Proof valid

A smaller surface

Leave the baggage behind.

Traditional API payments

Account.Identity.Card.API key.Billing profile.Purchase history.

The openzk way

Fund.Prove.Spend.
An honest boundary

Deposits and withdrawals settle publicly on Ethereum. The payment history between them does not need to.

Understand the exit

At the edge of your endpoint

Accept proof.
Skip the profile.

Private payments belong inside the request. Explore the protocol, or make your first payment in the playground.

View protocol source
Payment flow / Conceptual exampleTypeScript
const payment = await openzk.prove({
  amount: quote.price,
  service: quote.recipient
});

await fetch(endpoint, {
  headers: {
    "OpenZK-Proof": payment.proof
  }
});
One request. One proof.↗

Cash semantics. Without the ceremony.

Fund privately.
Spend anonymously.
Exit anytime.

Make your first note
Ethereum settlementZero-knowledge proofsOpen protocol