How we evaluate
Paying an AI agent is judged on why and how you are paying it. The criteria that matter:
- Reason for paying. Are you paying for a service as you use it, sending a one-off, or paying it from another agent? This decides the method.
- Payer type. Are you a machine paying programmatically or a human sending a payment by hand?
- Per-call versus one-off. Does the payment recur with usage or happen once?
- What you hold. Do you already hold USDC, or only fiat that must be converted first?
- Friction. How much setup does the method need before money moves?
- Attribution. Does the payment land with clear record of who paid and for what?
No method is best for every case, so start by naming why you are paying.
Why are you paying?
Before choosing a method, answer why you are paying the agent. If you are consuming a service it offers and want to pay per use, that points to x402, which settles each call automatically. If you are sending a one-off or voluntary amount, a tip, a sponsorship, a payout, that points to a payment link. If your own agent is paying it as part of a workflow, that points to agent-to-agent. And if you only hold fiat, you first have to convert before any of these.
Naming the reason resolves most of the choice, because the methods below are each shaped for a different reason. Paying for ongoing use is a different act from sending money once, and a machine paying is a different act from a person sending a payment, so fix the reason and the method follows.
The five realistic ways
In 2026 the realistic ways to pay an agent are x402 per-call, a payment link, a direct wallet transfer, agent-to-agent, and converting fiat first. They map onto the reasons above.
Way 1: x402 per-call
The standard way to pay an agent for a service is to call its x402-gated endpoint. The service returns a 402 with a price, your client, createX402Client from @blockchain0x/x402, settles it in USDC on Base, and the request retries and returns the result. You pay exactly for what you use, automatically, with no account.
It fits best when you consume an agent's service and want to pay per call, which is the common machine case. It needs you to hold USDC in a wallet and to call through the x402 client, and it prices sub-cent calls economically. Choose it whenever paying is part of using a service the agent provides, and see how-to-add-usdc-payments-to-ai-agent for the mechanics.
Way 2: A payment link
To send a one-off or voluntary payment, use the agent's payment link. Its public profile URL on Blockchain0x doubles as a shareable link, so you open it and send USDC with no per-call wiring. It is the lowest-friction way to move money to an agent once.
It fits best for tips, sponsorships, payouts, and topping up an agent you support, rather than paying per use of a service. It will not meter usage or settle automatically as you call, so it complements x402 rather than replacing it. Choose it when the payment is a single deliberate act rather than ongoing consumption, and see how-to-create-payment-link-for-ai-agent.
Way 3: A direct wallet transfer
If you know the agent's wallet and want to pay it directly, a wallet transfer sends USDC straight to it. This suits a known, specific payout to one agent outside the context of calling its service.
It fits best for a deliberate transfer to an agent whose wallet you already deal with, such as settling an agreed amount. It does involve handling the destination, and the direct payments path on the platform may return a transient error during the chain-adapter rollout, so for routine paying the x402 and payment-link methods are usually smoother. Choose a direct transfer when you specifically need to move a known amount to a known agent wallet.
Way 4: Agent-to-agent
When your own agent pays another, the payment is agent-to-agent. You give your agent a wallet tool built on the x402 client, and when it calls the other agent's gated service it settles in USDC from its own wallet, within its spend limit, with no human in either loop.
It fits best for autonomous workflows where your agent consumes another agent's service as part of its task. It is really Way 1 performed by an agent rather than your code directly, with the addition of the paying agent's own wallet and limit. Choose it when the payer is an autonomous agent you run, and the same x402 mechanics apply underneath.
Way 5: Fiat on-ramp first
If you hold only fiat, you cannot pay an agent directly, because agents settle in USDC. You first convert fiat to USDC through an on-ramp into a wallet, and then pay by one of the methods above.
It fits as a prerequisite step rather than a payment method itself: it is what you do before paying when you start from fiat. Once you hold USDC, x402 per-call or a payment link works as normal. Treat this as the on-ramp stage of paying an agent when your starting balance is fiat, not as an alternative to the on-chain methods.
Keep a record of what you paid
Whichever method you use, keep your own record of what you paid and why, because the payment is yours to reconcile. When you pay through x402, your client knows the call it paid for, so log the amount, the endpoint, and the result together. When you send through a payment link or a transfer, note what the payment was for, since a bare on-chain transfer carries little context on its own.
This matters more as the number of agents you pay grows. A month of paying several agents per call adds up to a spend figure you will want to attribute by agent and by purpose, and the only reliable way to do that is to record it as you pay rather than reconstruct it later from the chain. Treat your payment log as the source of truth for your side, the same way the agent you pay keeps its own receive-side record.
Summary comparison
| Way | Reason | Payer | Holds USDC first | Best fit |
|---|---|---|---|---|
| x402 per-call | Pay for a service | Machine | Yes | Paying as you use a service |
| Payment link | One-off / voluntary | Human or machine | Yes | Tips, sponsorships, payouts |
| Direct wallet transfer | Known payout | Either | Yes | A set amount to a known wallet |
| Agent-to-agent | Autonomous use | Your agent | Yes (its wallet) | Agent consuming another agent |
| Fiat on-ramp first | Prerequisite | You | No, converts | Starting from fiat |
How to pick
Name the reason and the method follows. If you are paying for a service as you use it, choose x402 per-call. If you are sending a one-off or voluntary amount, choose a payment link. If your own agent is the payer in a workflow, choose agent-to-agent, which is x402 performed by your agent. If you need a specific payout to a known wallet, a direct transfer fits. And if you start from fiat, on-ramp to USDC first, then use one of the others.
For the common case, paying an agent for a service as you consume it, x402 per-call is the answer, because it settles automatically per use in USDC with no account. To wire it, read how-to-add-usdc-payments-to-ai-agent; for one-off payments, see how-to-create-payment-link-for-ai-agent. Pricing is on the pricing page.