
AI agents now do real work. They research markets, write and test code, check freight rates and pull data from dozens of APIs to finish a single task. Sooner or later, an agent reaches a service that charges for access.
That is where things slow down. Most online payment flows assume a person is present to create an account, enter card details, store an API key or approve a monthly bill. Those flows work well for people. An agent acting on its own, mid-task, needs a way to pay in the same moment it asks for the data.
x402 is an open protocol built for exactly that. This piece explains what x402 is, how a payment moves from agent to API, where it is already useful, what a business needs to accept payments from software, and how Tazapay is making that easier.
x402 is an open standard that lets a client pay for a web resource inside the same HTTP request it uses to ask for it. The client can be an AI agent, a script or an app. The resource can be an API response, a dataset, a file or a unit of compute.
The name comes from HTTP status code 402. Every web request returns a status code: 200 means the request worked, 404 means the page was not found. Code 402, Payment Required, was reserved in the early days of the web for a payment system that never arrived, so it went largely unused for decades.
x402 gives that code a defined format. When a server returns 402, the response carries machine-readable payment terms: the amount, the accepted token, the network, the receiving address and a time limit. A server can list several options, and the client picks one it can pay. The client sends its payment in a request header, and the server confirms it in a response header, so no new endpoint, redirect or checkout page is needed, as described in Coinbase's x402 launch announcement.
Payments today run mainly on stablecoins such as USDC. The standard is designed to work across blockchain networks and to extend to other payment methods over time.
Coinbase introduced x402 in May 2025 as an open protocol. In July 2026, the Linux Foundation launched the x402 Foundation to govern it, with Coinbase contributing the protocol and 40 member organisations signing on, including Visa, Mastercard, Stripe, Google, AWS and Cloudflare. That matters for businesses evaluating it: x402 is now a vendor-neutral standard, not one company's product.
Three parties take part in every x402 payment: the agent that wants the resource, the API server that sells it, and a facilitator that checks and settles the payment. Here is the sequence for an agent that needs a freight rate from a paid logistics API.
A little more detail on the key steps:
For the agent, paying becomes one extra round trip, not a separate checkout process. For the API provider, every request can be priced and paid individually, which suits pay per call models better than prepaid credits or monthly plans.
An agent might call dozens of paid endpoints to finish one task. If every call had to wait for a payment to fully settle on a blockchain, the agent would spend more time waiting than working. x402 avoids this by separating two jobs that are usually bundled together: checking the payment and settling it.
Verification happens inside the request. The facilitator checks the signed payment against the server's terms. Every check works on the signed message itself, so none of them waits on the network. The nonce check is what stops replay: once a payment has been used, the same proof cannot pay for a second request.
Settlement follows, in the background. Once the payment passes, the server releases the data straight away, while the facilitator submits the transaction, pays the network fee and waits for confirmation. If a submission fails, recovering it is the facilitator's job, not the API's. Whoever runs the facilitator takes on the small risk between approval and final confirmation.
This split is what makes small, frequent payments practical. The cost of each payment comes down to the network fee, which is low on the networks x402 typically runs on. A request can be priced at a few cents, or less, and still make commercial sense.
The common thread is simple: one piece of software needs to pay another, at the moment it uses the service. The businesses best placed to sell to agents already price by usage, and their fastest-growing callers are automated.
x402 does not replace cards, bank transfers or invoicing. Those stay the right tools for people and for most business-to-business payments. It adds a rail for a new kind of buyer, one that needs to pay in the middle of a request rather than at a checkout page.
Adding x402 to an endpoint takes little code, since open-source middleware handles the 402 response itself. The harder part is everything behind the payment. A business that wants to sell to agents at scale needs answers to five questions.
The protocol is still young, and its governance only became vendor-neutral in July 2026. That makes now a good time for API and data businesses to plan for agent payments, before their own customers start asking for it.
In simple terms: Tazapay acts as an x402 facilitator for its merchants. API and data businesses can charge AI agents per request and keep the money in stablecoins or pay it out in local currency, without building any blockchain setup themselves. The merchant keeps running its own API, and Tazapay never sees that traffic, only the payment details it needs to check and settle each payment.
Getting started takes three steps:
To the agent, the merchant's API is a standard x402 endpoint. To the merchant's finance team, agent revenue is one more set of Collects.
Agents pay in stablecoins, but the merchant does not have to hold them. With Tazapay, agent revenue lands in the merchant's USDC wallet, where it can stay in USDC or be converted and paid out in local currency through Tazapay's existing FX and payouts. A data provider that has never touched a blockchain can price its API per call and still get paid in the currency it reports in.
Tazapay runs the payment checks and on-chain settlement described earlier and covers the network fees, so the merchant never needs to hold gas tokens. Only KYB-approved merchants can receive x402 payments through Tazapay, and payers are screened before settlement.
Because x402 runs on Tazapay's existing stablecoin payment infrastructure, agent revenue does not sit in a separate system. For businesses weighing how stablecoins fit their wider payment stack, our guide to stablecoin payments for global businesses covers the bigger picture.

When a payout bounces, someone pays for it in hours and fees. A typo in an account number, an account the payee closed months ago or a name that belongs to someone else all end the same way: returned funds, a waiting recipient and extra reconciliation work for your team. Tazamatch is the Tazapay tool built for that problem [1]. It tells you whether a payee's account is real and whether the name you hold lines up with the bank's records, and it does so while the money is still in your balance.
Below is a plain-language walkthrough of how Tazamatch works: what it checks, where it slots into a payout, the three ways to run it, how to read what comes back, how to use it from the dashboard or the API, and where it is available.
The point of Tazamatch is timing. Problems get caught when a payee is added to your records, rather than after a transfer has already gone out. Tazapay positions this as a way to cut down on failed payouts, spot suspicious payees sooner and give recipients more confidence, all without slowing your payout process down [2].
A check never moves money. Running Tazamatch sends nothing, holds nothing back from your balance and adds no beneficiary to your account. You simply get an answer to act on [1].
Payouts carry on while checks run. Verification sits alongside your payout operations rather than in front of them, so nothing already in motion is held up [2].
Every corridor answers the same way. Banks in different countries report very different data. Tazapay converts all of it into one standard format, so the rules you build for handling results work wherever your payees are [2].
Use it where it suits you. A check can run as you onboard a new payee, just ahead of a payout, or any other time you want one. Your developers can call it through the Tazamatch API, and your operations team can run it from the merchant dashboard [3][4].
Think of Tazamatch as a checkpoint between onboarding a payee and paying them. The product overview lays the journey out in four stages [1].
Under the hood, each check has the same three beats [5]. You send the payee's account details, Tazamatch opens a verification record with an ID beginning pyv_, and your team decides what to do: pay, review or reject. If you are adding a new country, or you are unsure what a corridor needs, you can first ask Tazamatch whether that corridor is supported and which fields it expects. That step is optional.
How you start a check depends on where it sits in your process, and Tazamatch offers three modes to match [5]. Whichever you pick, you get back a verification record that starts out as pending [3].
Whatever the corridor, a check ends up described by one of a handful of states, plus a match type when the account is found [6]. It opens as pending and then settles into a final state.
The API pages add one more outcome, failed. This is when the check itself could not finish, for example because the provider timed out or returned an error. You are not charged for a failed check [7].
A valid result also carries a match type, which tells you how close the name you sent is to the name the bank holds.
Valid plus no_match is a signal to look closer, not proof of a bad payee. The account is open, but the bank has a different name on file. Tazapay recommends a careful review before you pay. Whatever the result, including a partial_match or no_match, the decision to go ahead with the payout is still yours.
A finished check hands back a verification record. The full list of what it holds is in the API overview, and some corridors return more than others [2][6].
To see what a verification in a given corridor can return, look at its verification metadata [8]. It flags support for account existence, name check, match score, match type, corrected name, translated name and transaction activity.
If Tazamatch is switched on for your account, you can run checks straight from the Tazapay merchant dashboard [4]. There are three things you can do there.
Run a check. Open Tazamatch > Verify Payee, fill in the bank and payee details your corridor asks for, and submit. You see the state and match type on screen. It does the same job as the Create Verification API call.
Look back at past checks. Tazamatch > Verifications lists every check on your account with its state, match type, corridor and time. Open any entry for the full record, including its pyv_ ID and every field that came back.
See what a corridor needs. Under Tazamatch > Capabilities, pick where the money is going, the currency and how it will be paid, and the dashboard shows the fields that corridor requires and what it can check. You only need this when you are unsure.
On the API side, the Tazamatch API guide breaks integration into two main steps, with an optional corridor lookup before them [3].
Before you start (optional): look up the corridor. Send the destination country, plus the currency if you want to narrow it down, to Fetch Verification Metadata [8]. You learn whether the corridor is covered, which bank fields and bank codes it needs, which payee fields it needs (tax ID included), what it can check and its coverage figure. If a corridor is not covered, leave verification out for it.
Step 1: send the check. Call Create Verification in whichever mode suits your process [9]. You get a pyv_ ID back, with the state set to pending.
Step 2: collect the result. Use that ID with Fetch Verification, checking again until the state settles on valid, invalid or not_supported [10]. For a view across all your checks, List Verifications can narrow results by state, match type, destination country, currency, beneficiary, payout rail, date range or a keyword [11].
Let webhooks tell you instead. Rather than checking repeatedly, you can listen for verification webhooks [7]. One event, payee_verification.completed, arrives when a check ends as valid or invalid. The other, payee_verification.failed, arrives when a check could not finish, such as after a provider timeout or error, and carries no charge. Every webhook endpoint you set up receives both unless you turn them off. A not_supported result sends neither, because no check was actually attempted.
Plan for errors. The Tazamatch error codes fall into three groups [12]. The first covers bad or missing inputs, such as the payee type, name, email, phone, destination, country, currency, account number, bank identifier, or fields a particular corridor insists on. The second is a single code for corridors Tazamatch does not cover. The third covers provider-side trouble: rate limits, outages or an internal fault. For that last group, wait a moment and retry, and reach out to [email protected] if it keeps happening.
Tazamatch is available in 50+ corridors, with more being added, and what it can do differs from country to country [13]. The table shows, market by market, whether the name is checked, whether the bank's name for the account holder comes back to you, and the coverage figure Tazapay publishes.
Next on the roadmap. In Asia Pacific: China for business accounts, Hong Kong, the Philippines, Singapore and Taiwan. Turkey is next in Europe, and Canada in North America.
Countries ask for different bank and payee details. You can pull them per corridor from Fetch Verification Metadata, or use the table below, which carries the same information [8].
A few markets come with conditions. In China, only personal accounts can be checked for now, with business accounts planned. India is covered through two corridors: IMPS, which reaches every live IMPS member bank, and UPI. Poland works for business accounts only. Nepal sends back the account holder's name only on a strong match, and Uruguay sends it back partly hidden.
Five markets need a tax number. Saudi Arabia takes the National ID for a person or the Unified Number for a company, and also partly hides the returned name. Brazil takes a CPF for a person or a CNPJ for a company. Chile needs a RUT, Colombia a NIT and Ecuador a RUC. In Bangladesh and Bulgaria, reach is still limited, and Tazapay is working to widen it.