Trust
Security: how Payzilla is built
Early. Real money. Use with caution. Live on Solana mainnet with small limits. Not a certification.
The live account today
Signing
The signing service is a separate service from the API. The API does not hold the fee key.
Built and tested (live)Keys
The network-fee key is held in AWS KMS.
Built and tested (live)Limits
Per-seller limits on payment size, daily volume, unfinalized exposure and daily network fees, checked before anything is signed. No values are published, and no outside seller is on them yet.
Built and tested (live)
Limits
Reviews
Internal, with fixes and tests. No certifications.
Cards
No card-industry (PCI) compliance.
Production
No outside seller is live yet. Visitors can make a real payment of 0.01 USDC through the real-money demo; it goes to our own demo merchant. A separate account runs our own-funds payments on Solana mainnet.
Keys
No separate key per merchant yet.
Report a problem
Write to [email protected]. Our security.txt has the same contact. For ordinary bugs and anything else, use the same address. We will read what you send.
More detail
What is in place today
Connection records
In the preview environment, our hosting provider (Amazon Web Services) keeps technical records of network connections, including IP addresses, time and size but not content, for 30 days for security.
Payment tokens go wallet to wallet
The buyer’s wallet signs the transfer and the tokens go to the seller’s registered wallet. No part of the API accepts a buyer’s or a seller’s private key. Payzilla’s signer holds only the network-fee key, and that account does not move the payment tokens.
The signer signs only checked payments
Before anything is signed, Payzilla checks the payment strictly: the exact layout of the transaction, a plain token transfer from the buyer, the approved token and its decimals, the exact amount, the seller’s registered destination, a memo equal to the payment id, limits on compute and fees, and that the fee account is not moving tokens. It simulates the transaction first, and signs one payment once. There is no general-purpose signing endpoint.
Keys
On the live account, the network-fee key is held in a managed key service (AWS KMS) and used by a separate signing service. On devnet it is also held in KMS: in our private staging environment the API runs with that key and no development key, and its payments are signed that way. A local development key exists for local development only. The signer asks for a short-lived, single-use approval tied to one payment.
Row-level security separates each merchant’s data
Each merchant’s data is separated by row-level security in the database, and a request without a merchant identity sees nothing. Separate database roles are used for the API, the workers and the signer. We have tested this against a real PostgreSQL database on our own machines, and a 103-check role-isolation test has also passed on the managed staging database. Staging has two test merchants; the live account has three, all ours; no outside seller is live yet. Isolation is also checked with an unknown merchant that must see nothing.
An append-only, balanced ledger
Ledger entries are not changed or deleted: the database blocks it and entries are only added. Each set of entries must balance when it is committed, and a reversal must mirror the original.
Duplicate and replay protection
Database constraints stop the same transaction, the same buyer message or the same payload from settling twice. The signed transaction is stored before it is sent, and a retry resends the same bytes. A payment is marked failed only after the network shows it did not land.
Watching the fee account
If payment tokens ever appear in the network-fee account, signing freezes until the freeze is reviewed and lifted with a recorded approval. This monitor is built and tested with simulated balances. A separate low-balance alarm on the fee account also runs in staging. The live account also has alarms on the fee account.
Signed webhooks
Webhooks are signed with a timestamped signature, and deliveries go only to https addresses at public IPs. Redirects are not followed.
Start-up checks and logs
In the staging profile, the API refuses to start if it would use the development key, an embedded database, fewer than two independent connections to the network, or anything other than devnet. Logs are structured, and they redact secrets, web addresses and card-number-like digits. The API checks its own health, and shuts down gracefully so in-flight work finishes. These checks are tested locally and now run in the private staging environment.
Secrets
API keys are stored only as hashes and shown once. The dashboard runs on private staging behind an email sign-in and does not show the API key. It shows payments and services. The only changes it makes are to services: adding one, and pausing or resuming one, by an owner.
Card data
The card flow is designed so that card numbers do not reach our servers: the provider’s hosted fields collect them, and our API rejects anything that looks like a card number. It is tested against a mock provider. No real card provider is connected, and we claim no card-industry certification.
Card refunds and disputes (mock provider)
In the card flow, a refund is treated as an obligation: it is retried until the provider confirms it, and it is escalated if it keeps failing. An open dispute holds the payment instead of letting it slip through. A captured amount that does not match the payment, or a settlement line that contradicts our records, opens a reconciliation break and raises an alert. All of this is tested against a mock provider only.
The interactive demo
The demo page has its own guards: a human check (Cloudflare Turnstile), one run at a time, limits per address and per day, a time limit for each run, and a switch that turns it off. Its agent has a mandate: a maximum price per call, a daily budget and a list of allowed recipients. It runs on devnet with a test token that has no value. In the demo, a tampered price or recipient is refused before anything is signed.
Real network only on explicit settings
The software runs on a real network only when several explicit settings are all present together; if the real network is requested and any of them is missing, it refuses to start. The real-money demo runs on Solana mainnet.
Footnote: where the signing key is used on staging
The fee key is not customer money, but it is handled with care.
Today, on staging
- Internet
- API, with the signer inside it holds the permission to sign
- Key service (AWS KMS)
The signing checks are code inside the same service that faces customers.
In development
- Internet
- API cannot sign
- Signer service the only part allowed to sign
- Key service (AWS KMS)
A bug in the customer-facing API would then not give an attacker the permission to sign.
On the live account the signing service is a separate service from the API; the API does not hold the fee key. The devnet preview signs inside the main service with a staging key.
How it has been checked
- More than 1,000 automated tests pass against a real PostgreSQL database run on our own machines (last counted October 2026).
- Many test payments finalized on devnet on private staging, including an automatic one about every 20 minutes.
- Internal reviews, with fixes and tests: of the design, of the x402 build, of the demo showcase and of the card flow. They found real issues, and the fixes come with new tests. The findings of the latest card-flow review have been fixed and tested.
- Mutation testing: we deliberately break the code in small ways and check that the tests notice. Most injected faults are caught, and the ones that are not are written down.
- The full suite has not been run against the managed cloud database; the staging environment has been exercised with the role-isolation test and with end-to-end payments.
- The first end-to-end payments ran on the private staging environment: three test payments through Cloudflare to the API on AWS, signed by the KMS key, all finalized on devnet.
- All of this is internal.
What we are hardening next
- Next A separate network-fee key and account for each merchant, instead of one shared key.
- In development A key policy, least-privilege access and break-glass procedures for the managed key, plus alerts. Built and tested in the separate account for real money; staging is still to do. In development.
- Live account only A separate signing service, so the part of Payzilla that talks to customers cannot sign. Running on the live account; staging still signs inside the main service.
- Request limits for each seller on writes and on reads, and a block on a client address that keeps failing to authenticate: built and running on private staging. The live demo has limits per address and overall and a human check; merchants start with small limits.
- The last reconciliation checks. Reconciliation checks run continuously on the live account and on staging.
- Webhook secrets encrypted at rest, with rotation.
- Hardening the staging environment: the minimal container image now runs on staging and its registry scan reads no findings; more independent network data providers, and a review of the key policy and access, before it opens to trusted testers.
Related: how a payment works, the developer reference, and the roadmap.
Try one payment, or start selling
Real money. A Solana payment cannot be undone. The demo costs 0.01 USDC, about one US cent, from your own Solana wallet. Before you pay, check that the address bar says demo.payzilla.ai. Payzilla does not refund live demo payments. Tested with Phantom, Solflare, Trust Wallet and MetaMask.
Read the Terms and the Privacy note before you pay or sell.