What this covers

This page is about the currency a LangChain agent pays in: USDC, a dollar-pegged stablecoin on Base, and why that choice matters for an agent rather than just how the plumbing works. The plumbing is covered elsewhere; here the focus is the stablecoin itself, what its properties buy you when the payer is a LangChain agent making many small payments.

For the reusable tool that does the paying, see langchain-wallet-tool; for the step-by-step wiring, see how-to-add-payments-to-langchain-agent. The payment API product page is the broader reference. This page answers the question those leave implicit: why a stablecoin, and what it changes for the agent.

Why a stablecoin for a LangChain agent

A LangChain agent is a planner that makes many small decisions, some of which cost money. The currency it pays in shapes how well it can reason about those decisions, and a dollar-pegged stablecoin is the right fit for three concrete reasons.

The peg removes volatility. A price quoted as five cents is five cents when the agent decides and five cents when it pays, so the planner is not reasoning against a moving target the way it would with a volatile token. The low fee makes small payments viable. Base settles a sub-cent payment for a fraction of a cent, which matches the size and frequency of agent calls in a way a card or a high-fee chain cannot. And the dollar denomination is legible. The planner, and you, think in dollars, so a budget, a price, and a spend limit are all in the same familiar unit with no conversion. Put together, the stablecoin is not an incidental detail of the integration; it is what makes per-call agent payment something a planner can actually reason about.

How payment works

Mechanically, a LangChain agent pays in USDC by calling through the x402 client, which settles the stablecoin on a 402 and retries.

import { createClient } from "@blockchain0x/node";
import { createX402Client } from "@blockchain0x/x402/client";

const sdk = createClient({ apiKey: process.env.B0X_API_KEY! }); // sk_test_ -> Base Sepolia
const fetchWithPay = createX402Client({ sdk });

// The agent calls this (often wrapped as a tool). The 402's price is in USDC;
// the client settles it and retries. Amounts are 6-decimal base units.
const res = await fetchWithPay("https://api.example.com/paid-endpoint");

That is the same client the wallet tool wraps. The stablecoin part is invisible in the code, by design: you do not convert currencies or handle tokens, you just call, and the settlement happens in USDC underneath.

Pricing the planner can reason about

Here is where the stablecoin pays off inside LangChain specifically. Because every price is in stable dollars, you can give the planner price information it can actually use. A tool description can say a call costs about five cents, and that number stays true; the planner can weigh it against the value of the result and decide, without you having to feed it a live exchange rate or worry the cost shifted mid-run.

Pair that with the wallet's spend limit, also in dollars, and the agent operates in one coherent unit: it knows roughly what things cost, it has a dollar budget, and the wallet enforces a dollar cap. A volatile currency would break this; the planner would reason about a price that changed by the time it paid, and the budget would mean a different amount each hour. The stablecoin is what makes dollar-denominated agent reasoning possible, which is the property that matters most when the payer is an LLM planner rather than a script.

USDC versus a volatile token

It is worth being concrete about why not just use a regular cryptocurrency, since the question comes up. Imagine a LangChain agent paying for a data call quoted at the equivalent of five cents in a volatile token. Between the planner reading the quote and the payment settling, the token's value can move, so the agent might pay the equivalent of six cents, or four, for the same call. Multiply that across hundreds of calls and your costs wander for reasons that have nothing to do with usage, and the planner's reasoning about "is this worth five cents" is built on a number that is not stable.

A dollar-pegged stablecoin removes that entire class of problem. Five cents is five cents at quote and at settlement, so cost tracks usage and nothing else, and the planner reasons about a fixed number. The agent also never needs to hold a speculative position just to transact; it holds dollars, spends dollars, and its balance means the same thing tomorrow. For a workload that is about getting work done rather than trading, that stability is exactly what you want, and it is why the rail is a stablecoin rather than whatever token happens to be liquid.

Accounting stays in dollars

The peg pays off again after the fact, in your books. Because every payment was in USDC, your spend and revenue are already in dollars, with no conversion at some historical exchange rate to reconstruct. A payment.sent for five cents was five cents; a month of an agent's spending sums to a dollar figure directly.

That keeps reporting simple. You do not run a pricing oracle to value past transactions, you do not explain to finance why the same call cost different amounts on different days, and an agent's budget, its actual spend, and your accounting are all the same unit end to end. For anyone who has reconciled volatile-asset transactions after the fact, the dollar-denominated trail is a quiet but real saving, and it falls straight out of choosing a stablecoin as the rail.

Compatibility

The stablecoin payment path works wherever the x402 client does, which is wherever LangChain tools run.

When this fits

Paying in USDC fits a LangChain agent whenever it calls paid services at small amounts and often, which is most agent workloads that touch money. The stablecoin is the right unit when the agent needs to reason about cost, when sub-cent or few-cent payments must be economical, and when you want budgets and limits in dollars rather than a fluctuating token.

It fits less well when the agent never pays for anything (no currency needed at all) or when a single large, human-approved payment is the only transaction (a different rail may suit). For the common case, a planner making many small paid calls, a dollar-pegged stablecoin on a low-fee chain is the unit that makes the whole thing reason-able and economical at once.

Pricing

Paying in USDC is free to integrate; you pay the wallet platform fee per agent, on the pricing page: Free is $0 per agent per month at a 5% transaction fee, Pro is $9 at 2%, Business is $29 at 1%. The fee is a percentage of the USDC transacted, so it scales with use, and per-agent pricing means only the agents that actually transact cost anything.

What to ship today

Wire createX402Client into a LangChain tool, fund the agent's wallet with test USDC on Base Sepolia, and make one paid call, noting that the price you see is dollars and stays dollars. Give the planner the cost in its tool description so it can reason about it. For the reusable tool see langchain-wallet-tool. Pricing is on the pricing page.