For buyers

Everything else in these docs is written for the person who runs a site. This one is for the person on the other side: you're running an agent that reads tolled pages, and you need it to pay for them without you approving each read.

That means giving it money to spend, and deciding how much of it any one agent can reach. This page is about the three things that control that: the wallet you already own, the balance naulon keeps for you, and the agents that spend it. It also covers what each control on the Balance page actually does.

Three nouns, and they are not the same thing

Your wallet is yours. A passkey account you mint in the browser, or one you already had. You hold its key; naulon never does. Money moves out of it into your balance, and withdrawals go back to it.
Your balance is the pot naulon keeps for your agents to spend. You have exactly one on Test and one on Live, funded from your wallet, and it sits there until an agent spends it or you withdraw it.
An agent is an agent token. The token itself is the budget: a lifetime cap and an expiry, and which money it may spend, Test or Live. Give the token to your agent and it pays tolls on its own, with no prompt per read, up to what the token allows and what the balance's own limits allow.

Any number of agents draw on the same balance: a "research bot" token and a "scraper" token, each stopped by its own cap, each answerable for its own spend in the ledger. The separation between them is the cap and the record, not a separate pot of money. A second pot would only strand funds in the one your agent wasn't using.

Test and live

Switch with the Test / Live control at the top of the Balance page. Each side has its own balance; new buyers start on whichever side naulon defaults to.

Test USDC is free and worthless, which makes it the right place to prove the whole loop before any of it costs anything: open a balance, deposit, mint an agent token, watch a read get paid. A publisher settling in real USDC cannot be paid from your Test balance, and the refusal is explicit rather than a mysterious failure.

Test and Live never mix, and the fence is the agent token: a token minted against Test can only ever spend Test money, whatever a publisher settles in.

Networks are not a choice you have to make. A publisher decides which network they settle on, and your balance is funded on whichever ones your agents actually read. naulon moves it to meet them, and the page shows one figure covering all of it. Each move costs a small network fee and appears in your activity (below).

Getting USDC in the first place

naulon does not sell you USDC and never holds it. You bring your own, and everything below assumes you have some, so if you don't, this is the step before all of them.

On Test, you don't need to buy anything: Circle's faucet hands out test USDC for free, and the Add funds dialog links straight to it. Prove the whole loop there first.

On Live, USDC comes from wherever you already buy crypto: a centralised exchange, or a wallet you already fund. Whichever it is, the move is the same: withdraw USDC to your funding source's address, which the Balance page shows with a copy button.

Two things decide whether that arrives somewhere you can use:

Send USDC, not another token. A stablecoin that looks equivalent on an exchange's withdrawal screen is a different contract here.
Send it on the network the page names. The Add funds panel names one network next to the address, and an exchange withdrawal screen will make you pick one. They have to match.

The network named there is one you can actually reach, which is not always the one your reads settle on. Publishers settle where they choose, and the default here is Arc, Circle's own payments network: settlement is final in about a second and moving money off it costs a fraction of a cent. Kraken and KuCoin withdraw USDC to Arc directly, so the page will usually just name Arc. If your exchange has not added it, the page names the nearest network yours does offer, takes the deposit there, and moves the balance to Arc for you. Either way you never pick a network and you never bridge anything.

If the page does name a network your exchange will not send to, that is the one case where you have to move the money yourself. USDC reaches a network like that by being bridged from one you can withdraw to, through Circle's Cross-Chain Transfer Protocol: the USDC is burned on the network it is on and the same amount is minted on the destination. Circle publishes both an SDK and the contracts for it. Bridge into your funding source's address, and the Balance page picks it up from there.

Get either wrong and nothing bounces. The address is an ordinary EVM address, so it exists on every EVM chain and can hold any token. A mis-sent transfer lands at that same address, where nothing here can spend it, return it, or see it. Check both before you confirm the withdrawal, not after.

Your funding source's balance appears on the Balance page once the transfer confirms, and the page re-reads it whenever you come back to the tab, so returning from your exchange is enough, with nothing to press.

Setting a funding source

A funding source is the wallet you already control, outside naulon, that deposits move from and withdrawals move back to. You have one, and it serves both your balances, Test and Live alike. Three ways to have one:

Create a passkey wallet. A smart account minted in your browser, owned by your device's biometric. Depositing from it takes one tap (see below).
Connect a wallet you already own. Sign a message to prove it's yours, then deposit from it whenever you like. The key stays wherever it already was, not on this device, and you pay that transfer's network fee.
Paste an address you control. No signature, no connection: you, or a script you run, call depositFor on the Gateway contract yourself, sending USDC into your balance, and record the transaction here. Nothing about the deposit runs through naulon's UI: you're proving a payment you already made, not asking naulon to make one.

Whichever you pick is the source both balances use. That is deliberate: a balance goes home to your funding source when you withdraw it, so a second source would mean money leaving by an address you were not looking at.

Changing it

While you hold any balance, your funding source is fixed. To change it, close your balances and the choice opens up again on the setup screen. Each one has to be emptied first, so nothing is left pointing at the old address.

Two things are worth knowing before you do:

Money in the old source stays there. naulon stops showing that address once a new one lands, and if it was a passkey wallet, the page can no longer sign for it. Send anything it holds somewhere you control first; the screen tells you the amount before you confirm.
Withdrawals pause for 24 hours afterwards, on both balances, and we email you. That is the protection every exchange applies against someone changing the destination and draining in the same motion.

Adding funds

How a deposit reaches your balance depends on the source:

Passkey. One tap: a fingerprint, face, or PIN prompt. The network fee is sponsored, so it costs you nothing beyond the deposit itself.
Connected wallet. Two confirmations: an approval, then the deposit. You pay the network fee on both.
Pasted address. However your own depositFor call confirms, plus this product recording the transaction hash you give it.

None of it is instant, because Circle only credits a deposit once the chain it's on has reached finality. About a second on Arc. About ten seconds on Avalanche or Polygon. Fifteen to twenty minutes on Base and the other Ethereum L2s, which settle to Ethereum and wait on its blocks. The page shows the wait and keeps working while it runs; once the deposit lands, an agent can spend it immediately.

Only a deposit made through depositFor gets credited. The address your balance is held against exists on every EVM chain, so a transfer sent to it directly, as a plain transfer or as a different token, is not bounced: it lands at that same address and is credited to nothing. No toll can spend it and Withdraw cannot reach it. This is why the page does not offer that address as somewhere to send money: use the deposit dialog, or make the depositFor call yourself, and confirm the chain first.

If it happens anyway, the money is not lost. Closing that balance is refused while its address holds anything, and the refusal carries a Send it to your funding source button: we sign one transfer from that address to the funding source you already set, and pay the gas. You cannot choose the destination: it is your funding source or nothing, which is what makes it safe as a single press. That covers USDC on the network the balance was being funded on. A different token sits at the same address where nothing sweeps it and nothing here can recover it. Get in touch for those.

Keeping your balance where your agents are

Your agents read whoever you point them at, and different publishers settle on different networks. Rather than asking you to guess that in advance, naulon watches where your agents tried to pay and could not, and moves part of your balance there. It happens in the background, takes about fifteen minutes, and your agents keep spending the rest while it runs. You see it on the balance page as money moving into place.

Each move costs a small network fee, taken from the balance, which is why it is never done to satisfy a single read: a fee that size against a sub-cent toll would cost more than the read. The Add funds dialog says this before you deposit, and every move is a line in your activity, Moved into place with the fee it cost, so you can see what was spent doing it rather than work it out from a balance that came back smaller.

Money only ever moves to a network naulon serves. A publisher settling somewhere we do not support is not a place your balance is sent to chase; that read simply goes unpaid and is reported as unreached.

Withdrawing

Withdraw moves USDC out of your balance back to your funding source: all of it, or an amount you choose. Nothing about it needs a signature from you: the burn is signed by the key naulon holds for that balance, Circle attests it, and naulon's own relayer submits the transaction that lands the USDC at your funding source, paying the gas for it. Circle's network fee is charged on top of the amount, so the full amount reaches your funding source and your balance pays the amount plus the fee. That is why "all of it" is your balance less one fee, and why the dialog states all three figures before you press.

It usually lands within a minute or two. If the landing transaction is still on its way when the request returns, the page shows the amount as outgoing and keeps checking on its own. A withdrawal is written down the moment Circle attests it, so a hiccup between the burn and the landing is retried, never lost.

Three things can hold a withdrawal up:

A deposit that hasn't finished confirming. You can't withdraw money that hasn't landed; wait out the chain's finality first.
The daily count. Each withdrawal costs naulon a transaction, so an account may start a limited number per rolling 24 hours, three on this fleet, across both balances. The dialog shows how many are left and when the next one opens.
A changed funding source. After you point your account at a different address, a new passkey included, withdrawals pause for 24 hours on both balances, and we email you. That is the protection every exchange applies against someone changing the destination and draining in the same motion. If the email surprises you, sign in and change it back.
A balance smaller than the network fee. Moving it would cost more than it moves, so the dialog says so and moves nothing rather than spending your money to send you less than nothing. Tolls are sub-cent, so a balance can end up here. The fee is the chain's, not ours, and it varies by chain: a fraction of a cent on Arc, about a cent on Base, and dollars on Ethereum. The dialog names the number before you confirm.

You also get an email for every withdrawal, with the amount, the destination and the transaction.

Agents and their budgets

An agent token is what actually lets an agent spend. Mint one at /buyer/agents, choose which money it may spend, and give it to your agent. The token is shown once. From then on it pays tolls on its own, inside two numbers you set when you mint it: a lifetime cap (the most it will ever spend, in total, across every read) and an expiry (when it stops working). Both are fixed to the token; there is no separate session to open, fund, or renew.

A token holds a budget, not money. It names Test or Live, or follows your default side, and spends that side's balance; it never has a pot of its own that could be emptied, moved or left behind. Change which side it spends on at any time from its card.

Each agent's card shows what it has actually spent against its cap, and over how many reads, so "what is this agent costing me" has an answer per agent, not only in total.

Limits

Set on the balance, not the agent, so they apply to every token spending from it:

Maximum per read. The most any one read may cost, so a single expensive page can't drain the balance in one payment.
Minimum per read. An optional floor that skips junk-priced reads.
Daily budget. The most that may be spent in a rolling day, across every agent spending from that balance.

All three are optional and manual. Nothing derives them for you, and they stay put until you change them. naulon also enforces its own hard ceiling on any single payment underneath yours, so leaving the maximum unset does not mean unlimited.

Closing a balance

Close ends a balance. It's refused while the balance holds anything, or has a deposit still confirming. Withdraw first, or wait for the deposit to land and withdraw that. Closing does not delete your spend history.

You close a balance to change your funding source, which is locked while one is open. Your agent tokens are unaffected: a token names a side, not a pot, so there is nothing for it to be left pointing at. Open a balance on that side again and the same tokens spend from it.

An older balance

If you held more than one balance on a side before naulon collapsed them into one, the extra ones still show on the page with whatever they hold. Nothing new binds to them and no agent spends from them. Move it out is an ordinary withdrawal, so it sends what's in one home to your funding source less the same network fee, and the daily count and the source hold apply to it exactly as they do anywhere else. From there you can deposit it into the balance that stands. The page states the wait and the fee before you press. An empty one is just removed.

What naulon can and cannot do with your money

naulon holds one key, and it is not your wallet's. Your balance sits at an address whose signing key we generate when you open the balance, encrypt at rest, and keep for as long as the balance exists. We do not delete it, even if you empty it. The key to your own wallet is a different thing entirely and never leaves your device or your own wallet software.
That key can move money two ways only: paying a toll, or withdrawing to your funding source when you ask. There is no path from it to a payout to us, or to anywhere else.
A withdrawal cannot be sent to us. The relayer that submits the landing transaction pays gas and signs nothing about the destination, which is inside Circle's attestation, and the fleet refuses any withdrawal whose destination is one of its own addresses, the balance's own signing address, or a token contract.
You can withdraw your balance at any time, less the one network fee the withdrawal itself costs. Nothing about the key's lifetime requires you to leave anything else behind.
We never hold a pool. There is no shared pot and no payout queue; your balance is tracked separately from every other buyer's.
Humans read free. The toll is for automated readers. A person opening the same page reads it free.

What your agent reads before it pays

A growing number of sites publish their terms in a machine-readable form: RSL, an open standard that hangs a licence off robots.txt, an HTTP header, or a <link> in the page. It states what an automated reader may do with the page and what that costs.

Your agent reads it, and it is not decoration:

A page whose licence forbids AI use is not bought. The site said no in public. No budget setting overrides that, and none of the spend controls above would have stopped it, because the money was never the problem.
A page that routes licensing through a licence server gets one. The standard says a client must obtain the licence from that server before access, whatever the price on the page says, so paying without one would move money and license nothing. Your agent asks that server for a licence, using credentials you configure for it, and presents what it gets back when it fetches the page. With no credentials configured, or if the server turns the request down, the read is skipped and you are told which of the two happened: a key you can fix is a different problem from a publisher who will not deal with you.
A quote noticeably above the published price stops for you. The read becomes an approval instead of a payment. A published price and a quote are allowed to differ a little; a page that publishes one number and charges a multiple of it is worth a look.

The lookup costs one small request per site, cached for the run, and every failure, whether no licence, no robots.txt, or an unreachable host, leaves your agent exactly where it was before: reading the 402, and paying what your controls allow. A site that publishes nothing is not treated as a site that permits everything.

The 402 itself

If you are writing your own client rather than using ours, the refusal is readable without any naulon code. A tolled read answers 402 with:

crawler-price, the price as a currency and an amount, as in crawler-price: USD 0.001. This is the vocabulary the large crawlers were already trained on, so a client that knows nothing about x402 can still see what a page costs.
A JSON body of {error, message, offer}, the shape @crawlertoll/core uses. The offer names the price, the recipient, the rail and an expiry, with naulon specifics under offer.metadata: which of the two things a toll sells (a read or a citation), and where to find the licence afterwards.
PAYMENT-REQUIRED, unchanged: the signed, nonce-bound, per-leg payment payload an x402 client actually pays from.

The split matters. The body advertises; the header obligates. A client that tries to pay from the body alone has not been handed enough to pay, deliberately. The body exists so a price can be read, not so a payment can be forged from it. Prices in the two can never disagree; they come from one builder.

A successful paid read answers 200 with crawler-charged, which is what actually settled rather than what was quoted. The two differ when a payer forgoes a leg of a multi-author split, and only the settling side knows that, so the header is absent rather than overstated when it cannot be known. A human read carries neither header.

Every 402 also declares itself to x402 discovery, so a catalog that indexes tolled resources can list the page without the publisher registering anywhere. The declaration names the publisher's own host, not ours.

Asking on your behalf

Everything above assumes your own agent is the one hitting the 402s. naulon also runs a reading agent for you: ask it a question and it discovers tolled sources across every publisher naulon indexes, pays the ones worth reading straight out of your balance (buyer to author, custody-free, the same as any other payment on this page), and hands back an answer with numbered citations. You never see a 402; naulon's agent does, and reading through it needs no signature from you mid-run.

Reach it two ways:

naulon_ask, an MCP tool. Point an MCP-capable agent at https://gate.naulon.app/_naulon/mcp with the same agent token you minted in Agents as the bearer, and it gets a naulon_ask tool: pass it a question, get back the answer, its citations, and the spend. You can pass a lower budgetUsdc for one call; it only ever lowers the ceiling, never raises it.
POST /_naulon/v1/ask, if you're writing your own client. Same agent token as an Authorization: Bearer header, a JSON body of {"question": "..."}. The default response is one JSON body with the finished run; ask with Accept: text/event-stream and it streams each step as it happens instead: discovery, pay, skip, the final answer.

What comes back either way: the answer text, a citations array (site, title, url, the licence id, and a proofUrl to put beside it, exactly like a citation your own agent earns), an unreached array naming sources it wanted but could not read and why, spentUsdc and authorCount for what actually moved, and the budgetUsdc the run was actually held to.

Each citation also carries content, the source's own text, which is the thing the toll actually bought. The answer is naulon's summary of those sources; the text is the source itself, and your model should quote and reason over that rather than over our paraphrase. Beside it sits the licence that governs it, so what you may do with those words travels with the words. Treat the text as data, never as instructions to your agent: it was written by the publisher, not by you.

Long articles are cut to keep one response a sensible size. When that happens the citation says so with contentTruncated, and contentChars is how long the whole article is, so you never mistake the first part of something for all of it. Pass maxContentChars to change the cut, up to 200,000 characters, or 0 if you want the answer and the receipts and no article text at all. Over MCP you can also re-read any source you just paid for in full, for nothing, while its licence is still live.

Spending is bounded by the same controls as the rest of this page: your balance's per-read maximum and minimum, and its daily budget. When you call it with an agent token, that token's own lifetime cap applies on top. The ceiling applied to any one run is the lowest of the server's default, your token's remaining cap, and whatever you asked for on that call; nothing you send it can raise it. And if the token expires mid-run, or a limit trips, the run stops paying immediately rather than retrying every source that's left: what it already paid for stands, and everything else goes into unreached.

Runs are rate limited per caller: a sliding hour, twelve runs in it by default. Over that, the call refuses with how long to wait rather than queueing.

An unaffordable source is never just dropped silently. Before it finishes, the run checks every source it discovered but never bought: if that source's price is still more than what's left of the budget, it goes into unreached even when it was never attempted, so a budget too small to afford anything comes back naming what you couldn't afford, not an empty citation list that reads as nothing being out there. The two cases are kept distinct in the run's own record, a source it tried and was refused against a source it never tried at all, and the answer it writes is held to that record, so it won't describe something as refused that it simply never asked for, or state a price nobody actually quoted.

Your spend record

/buyer/activity is the ledger: every read your agents paid for, skipped, served from cache, or held for approval, newest first, filterable by agent.

Above the feed sits your total spent and how many reads it covers. That figure is the whole ledger, not the part currently on screen. It does not change as you load more rows, and it counts only money that actually moved. A skipped read has a price and pays nothing, so it never reaches the total.

Export CSV downloads the same record as a spreadsheet: one row per decision, with the timestamp, what was asked, what was paid, which agent, and the settlement reference where there is one. Amounts are in USDC. It is the whole ledger rather than the visible page, so it is the file to attach to an expense claim.

Showing your work

Each payment hands your agent a signed licence. Keep it: it is the artifact that proves a citation was licensed, naming what was bought, for how much, and which wallet was paid.

Anyone can check one at naulon.app/verify. The signature is checked against the issuing gate's published keys, in their browser, with us offline. That is the point: a reader auditing your output does not have to trust naulon, or you, to confirm the source was paid for.

You do not have to hand anyone the document. Every tool that returns a licence also returns a proofUrl, naulon.app/verify?host=<publisher>&jti=<id>, and that is what a citation should carry beside the source. Opening it fetches the record from the publisher's gate and runs the same check; the reader sees the author who was paid, the amount and the on-chain settlement. Put it next to every citation your agent emits: a citation with a link a stranger can open is worth more than one with an id they cannot.

Two kinds arrive there. An access licence is the short-lived token your agent presents to re-read an article for free within its window. A citation record is permanent and grants nothing. It exists to be cited months later, when the access window is long closed and the only question left is whether the payment happened.

Buying a licence over a scope and period

Everything above pays one read at a time, at the door, after your agent has already decided to fetch a page. /buyer/licences is the other way to buy: a licence over a scope (a set of paths on one site) and a period, paid for up front, before anything is read. It settles through the exact same rail as a per-read toll (the same 402, the same buyer-to-author legs, the same custody-free rule), so the only thing that's different is what's being bought: not one page's toll, but the right to read a whole section for a stretch of time.

Pricing it costs nothing. Name a site, a path pattern (/articles/*), which of the sold terms you want (ai-input, ai-index, search; training rights are never sold this way), and a period (a day, a month, a quarter, a year, or any custom number of days up to 366). The page then prices every page on that site the pattern actually matches, at the same per-page price a toll would charge, summed into one total. The quote shows that total and the exact wallet each author on it is paid, before you commit to anything: the split is the whole claim this product makes, and you shouldn't have to take our word for it.

Buying settles the price out of your balance, one signed leg per author, same as any other payment here. What you get is not a wildcard: the licence names the exact pages that existed and had a payable author at the moment you bought it, not "everything under this path, forever". A page the site publishes next week is not covered, because nobody was paid for it yet. Your held licences show both: the pattern you asked for, and the actual list of pages it grants.

To read against a licence you hold, mint an access licence for it, the same short-lived, unrevocable token described above in "Showing your work", scoped to the pages you're about to read, or the whole licence if you don't say. Fetch a fresh one whenever you need it; the licence is what makes that free, for as long as its period is running.

When the period ends, that stops: you can't mint another access licence against it, and reading again means buying again. What survives is the citation record, the same permanent proof this page already describes, untouched by the period lapsing, because a licence was never a promise to keep reading. It was only ever the receipt that, for that stretch of time, you had paid.