For buyers

This page is for the other side of the toll: you run an agent that reads tolled pages, and it needs to pay for them without you approving each read. It covers the wallet you own, the balance naulon keeps for you, the agents that spend it, and each control on the Balance page.

Three nouns, and they are not the same thing

• Your balance is what your agents spend. You have one on Test and one on Live. You fund the Live one by sending USDC to its deposit address, and it holds the money until an agent spends it or you withdraw it. The Test one is filled from Circle's faucet.
• Your withdrawal address is used on Live only: a passkey wallet you mint in the browser, a wallet you connect, or an address you paste. You hold its key; naulon never does. Every withdrawal goes to it, and nowhere else.
• An agent is an agent token. The token is the budget: a lifetime cap, an expiry, and whether it spends Test or Live money. Give it to your agent and it pays tolls with no prompt per read, up to the token's limits and the balance's.

Any number of agents draw on the same balance, for example a "research bot" token and a "scraper" token, each stopped by its own cap and recorded separately in the ledger. They share one balance so funds are never stranded in a pot your agent isn'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 has no value, so prove the whole loop there first: 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 says so.

A token minted against Test can only spend Test money, whatever a publisher settles in.

Your balance can sit on more than one network, and the page shows one figure for all of it. When money sits on a network your agents haven't been paying on, the page offers to move it, with Circle's fee shown first. Nothing moves until you press Move.

Getting USDC in the first place

naulon does not sell you USDC and never holds it. You bring your own.

On Test, press Get test USDC on your Test balance. naulon requests test USDC from Circle's faucet and deposits it into your balance, ready for your agents about a minute later. Each Test balance gets one top-up a day. If it's used or the faucet is busy, the page shows a link to Circle's faucet: send test USDC to your deposit address yourself and it moves into the balance on its own. Nothing withdraws from a Test balance.

On Live, send USDC to your deposit address from wherever you already buy crypto: an exchange, or a wallet you already fund. The Balance page shows the address under your balance, and Add funds shows it in full, with a QR code for a phone. It takes USDC on Arc and on Base, and it lands in your balance on its own: in about a second on Arc, and fifteen to twenty minutes on Base, which waits on Ethereum blocks.

Two things decide whether it 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 Arc or Base. An exchange's withdrawal screen lists networks and will make you pick one.

Arc is the default settlement network, Circle's payments network, and Kraken withdraws USDC to it directly. If your exchange only offers Base, send on Base: the money lands in your balance and pays any site that settles on Base. If your agents haven't been paying on Base, the page offers to move it to Arc, where a site that doesn't choose a network is paid.

If your exchange offers neither, bridge the USDC yourself through Circle's Cross-Chain Transfer Protocol, which burns it on one network and mints the same amount on another, and send it to your deposit address on Arc or Base.

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 different token, or USDC on another network, lands at that same address, where nothing here can spend it, return it, or see it. Check both before you confirm the withdrawal on your exchange.

Your withdrawal address

Your withdrawal address is a wallet you control, outside naulon, that withdrawals go to. Only Live needs one. There are three ways to set it:

• Create a passkey wallet. A smart account minted in your browser, owned by your device's biometric. It can also add funds to your balance with one tap.
• Connect a wallet you already own. Sign a message to prove it's yours. It can also add funds directly, and you pay that transfer's network fee.
• Paste an address you control. No signature and no connection. Withdrawals go there; to add money, send USDC to your deposit address.

You have one withdrawal address, not one per balance, so withdrawals always go to the address you're watching. A passkey wallet is registered with Circle for real money only, so it never signs anything on Test.

Changing it

Press Change under Money out. You can change the address while a balance is open, which is what lets you recover if you lose the phone that holds your passkey.

• You need a second factor. Changing or removing the address asks for a passkey or an authenticator app, set up under Security. A first address doesn't.
• Money at the old address stays there, and stays on the page. It is listed under Previous withdrawal addresses for as long as it holds USDC. A passkey address keeps Send and Add to balance on any device that still has its passkey.
• Withdrawals pause for 24 hours afterwards and we email you. The email has a link: if you didn't make the change, open it to freeze your balance and put your old address back. On an organization's balance the address stays put; see below.

If something changed that you didn't do

Every email about your withdrawal address or your second factor carries a link. Opening it and pressing Freeze my balance stops your agents paying, stops every withdrawal and undoes that change: your previous withdrawal address comes back, or the second factor that was added is removed. It works without signing in, in case you can't. While the freeze holds, no new agent token can be created either, so whoever has your password can't spend your balance on a site they own.

Then reset your password. To lift the freeze, sign in with a second factor you already had before the report and press Lift the freeze on the Balance page. A factor added after the report can't lift it. Without one, reply to the email and a person will check it's you.

Second factors and recovery codes

Adding or removing a second factor also pauses withdrawals for 24 hours and emails you, the same protection a changed address gets. When you set up your first factor you get ten recovery codes. If you lose the device, use one at the sign-in challenge: it removes your factors so you can set up a new one. Each code works once, and Create new codes replaces the whole set.

Adding funds

Send USDC to your deposit address and naulon deposits it into your balance for you. The network fee for that comes out of the USDC that arrived, usually a fraction of a cent. On Arc it is the gas itself. On Base it is the transaction's gas cost with a small margin, paid to naulon in the same transaction because Base gas is paid in ETH; Activity shows the exact amount. A very small transfer waits at the address until more arrives, and on Base a deposit also waits while gas would take a large share of it. While a deposit is on its way, the page shows it as arriving.

If your withdrawal address is a passkey or connected wallet that already holds USDC, Add funds can also take it from there: open Or move it in from your withdrawal address, pick an amount and confirm. The option appears only while that wallet holds something. A passkey deposit is one tap; a connected wallet asks for two confirmations, an approval and the deposit.

If a different token, or USDC on another network, reaches your deposit address, nothing sweeps it and nothing here can recover it. Open a support thread from Support in the menu.

Moving money between networks

Each publisher settles on a network it chose, and your agents pay it from your money on that network. When part of your balance sits on a network your agents haven't been paying on, or your agents keep failing to pay on another network, the Balance page offers a move. It says why, from where to where, how much, Circle's fee, and what you'll have when it lands.

Nothing moves until you press Move. Press Not now and the offer comes back on your next visit, because the money is still where it was. A move usually takes about a minute, your agents keep spending the rest meanwhile, and it appears in your activity as Moved between networks with its fee. If the figures change between the page loading and your press, the move is refused and the page shows the new ones.

Money only moves to networks naulon serves. A read from a publisher on an unsupported network goes unpaid and is reported as unreached.

Withdrawing

Withdraw sends USDC from your Live balance to your withdrawal address, on Arc or Base, which you pick in the dialog. All of it, or an amount you choose. You sign nothing: the key naulon holds for that balance signs the burn, and Circle delivers the USDC to your address. Circle's fee comes off your balance on top of the amount, so the full amount arrives. The dialog reads Circle's fee for the network you picked and shows the fee, what leaves your balance, and what arrives, before you press.

It usually lands within a minute. Until it does, the page shows the amount as outgoing and keeps checking. A withdrawal is recorded the moment Circle accepts it, so a delay is followed, never lost.

Four things can hold a withdrawal up:

• A deposit that hasn't finished confirming. Wait for the chain's finality first.
• The daily count. An account may start three withdrawals per rolling 24 hours. The dialog shows how many are left and when the next one opens.
• A changed withdrawal address or second factor. Withdrawals pause for 24 hours and we email you. If the email surprises you, use its link to freeze your balance.
• A freeze you started. Nothing leaves until it's lifted, as described above.
• A balance smaller than the fee. The dialog says so and moves nothing. Tolls are sub-cent, so a balance can end up here. The fee is Circle's, not ours, and the dialog shows it before you confirm.

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

Agents and their budgets

Mint an agent token at /buyer/agents, choose which money it may spend, and give it to your agent. The token is shown once. It pays tolls within two limits you set at minting: a lifetime cap (the most it will ever spend across every read) and an expiry. There is no session to open, fund or renew.

A token holds a budget, not money. It spends the Test or Live balance, or follows your default side; change the side at any time from its card.

Each agent's card shows what it has spent against its cap, and over how many reads.

Buying for an organization

An organization can hold its own balance, separate from every member's, and it needs no site to do it. Pick the organization in the switcher at the top of the menu and open its Buyer space: the balance page, its controls and every agent token you mint there act for that organization. Pick Just me to pay from your own balance again.

What you can do there depends on your role in that organization:

Everyone who can see the balance also sees every agent token that pays from it, with who made it and what it has spent. Owners and billing managers can revoke any of them. Only the person who made a token can change its cap or which money it spends, connect it to a client, or rotate it.

An agent token minted for the organization stops working within a minute if its maker loses the role that let them mint it, and at once if they leave the organization. Every change to the organization's balance or withdrawal address is recorded in its audit log, with who made it.

The organization's security notices go to everyone who can manage its balance, and each email says which of them made the change. Its first withdrawal address is announced the same way. When one of them adds or removes a second factor, the organization's withdrawals pause for the same hold yours would.

Each of them gets their own "Wasn't you?" link, and it only works while they still manage the balance: someone who has left the organization can't use the one in an old email. Pressing it freezes the organization's balance but leaves the withdrawal address where it is, because on a shared balance the previous address may not be safe either, and every manager is told who reported it and whose change it was. To finish:

• Set the address, if it's wrong. Any manager the report doesn't name can, signed in with a second factor they had before the freeze.
• Lift the freeze, the same way. The person whose change was reported can't lift it, unless they're the one who reported it.

Only someone who can manage the balance can give the Billing manager role, change it or remove someone who has it.

Connecting an agent

The Connect dialog on each agent's card gives you a snippet per client. Two cover most setups.

The plugin works in Claude Code and Codex, and in a ChatGPT workspace once its admin imports naulonapp/naulon-plugins as a GitHub marketplace. Each client takes the token its own way.

# Claude Code
claude plugin marketplace add naulonapp/naulon-plugins
claude plugin install naulon@naulon --config NAULON_AGENT_TOKEN=nln_agent_...

# Codex CLI: it reads the token from your environment.
export NAULON_AGENT_TOKEN=nln_agent_...
codex plugin marketplace add naulonapp/naulon-plugins
# then run codex, type /plugins and install naulon

Claude Code keeps the token in its secure credential store. Run the install line again with a new token to replace it, or use /plugin configure naulon@naulon. Without a token it does not start the server.

For Codex, put the export in ~/.zshrc or ~/.bashrc. Without it the server never starts, and nothing tells you so. The Codex IDE extension does not run plugins.

The plugin adds commands to ask, research, discover, fact-check and check citations, and one to verify a Citation License offline.

Plugins from this marketplace don't update on their own. In Claude Code run claude plugin marketplace update naulon && claude plugin update naulon@naulon, or turn on auto-update for the marketplace under /plugin. In Codex run codex plugin marketplace upgrade naulon. Claude Code used to read the token from NAULON_AGENT_TOKEN too. If you set it up that way, run the install line once after updating so the plugin has its own copy.

A hand-added server in Claude Code:

claude mcp remove naulon -s local 2>/dev/null; claude mcp remove naulon -s user 2>/dev/null
claude mcp add --scope user --transport http naulon https://gate.naulon.app/_naulon/mcp \
  --header "Authorization: Bearer nln_agent_..."

claude mcp add refuses a name that already exists, so the first line clears it. Run both lines again after you rotate a token.

Use the plugin or the hand-added server, not both. Claude Code keeps one server per URL, so a hand-added naulon hides the plugin's copy, and the plugin runs with the hand-added entry's token.

After connecting, restart the client and have the agent call naulon_status first. It reports the balance the agent spends from, the budget left on its token, and what to do if either is empty. When the token is rejected, the tools and prompts (ask, research, discover, verify) disappear from the client, so a missing tool usually means a revoked or mistyped token.

Each token may open a limited number of MCP sessions per hour. A client normally holds one session and reuses it; one that reconnects for every call will be refused with a rate_limited error naming when to retry.

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 stay as you set them. naulon also enforces its own hard ceiling on any single payment, so an unset maximum is not unlimited.

Closing a balance

Close is refused while the balance holds anything or has a deposit still confirming. Withdraw first. Closing does not delete your spend history.

You don't need to close a balance to change your withdrawal address. Your agent tokens are unaffected, because a token names a side, not a balance; 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 merged them, the extras still show with whatever they hold. No agent spends from them. Withdraw it is an ordinary withdrawal to your withdrawal address, less the network fee, with the same daily count and source hold. From there you can deposit it into your current balance. The page shows the wait and the fee before you press. An empty one is 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, even if you empty it. Your own wallet's key never leaves your device or 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 naulon 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 withdrawal's network fee.
• 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. Only automated readers are tolled.

What your agent reads before it pays

Many sites publish their terms in RSL, an open standard that links a machine-readable licence from 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:

• A page whose licence forbids AI use is not bought, whatever your budget settings.
• A page that routes licensing through a licence server gets a licence first. The standard requires a client to obtain the licence from that server before access, so paying without one would license nothing. Your agent requests one with credentials you configure and presents it when it fetches the page. With no credentials, or if the server refuses, the read is skipped and you are told which: a key you can fix is a different problem from a publisher who won't deal with you. When the licence server is naulon's own, your agent without credentials buys the read through the 402 instead, which is the same sale.
• A quote well above the published price stops for your approval instead of being paid. Small differences are allowed.

The lookup costs one small request per site, cached for the run. If it fails (no licence, no robots.txt, an unreachable host), your agent falls back to reading the 402 and paying what your controls allow. A site that publishes nothing is not treated as permitting everything.

The 402 itself

If you write your own client, the refusal tells you everything without any naulon code. A tolled read answers 402 with:

• PAYMENT-REQUIRED: the base64 x402 v2 payload your client pays from. Its error field says in one line what to pay, on which network, and that a Circle Gateway deposit comes first.
• crawler-price: the price as a currency and an amount, as in crawler-price: USD 0.0011. The large crawlers already read this header.
• Link: the site's terms as rel="payment" and this guide as rel="help".
• A JSON body. error, message and offer give the price and the publisher. After them:
  • forYourUser.text: one sentence for an assistant that cannot pay to pass on. The page is free to read in a browser, and it says where.
  • howToPay: the network in words, the USDC contract, which leg accepts[0] covers, and the steps. When accepts[0].extra.name is GatewayWalletBatched, the first step is a one-time deposit into Circle Gateway on that network: payments draw on that balance, not on your wallet, so a funded wallet with no deposit is refused.
  • links: this guide, the site's terms, where to set up an agent wallet, and the MCP server.

Send Accept: text/markdown to get the same 402 as prose, which is what most LLM fetch tools read best. A browser gets a readable page.

Pay from the header, not the body. The body explains the payment; only PAYMENT-REQUIRED is signed and nonce-bound. Both come from one builder, so their prices always agree.

The price covers every leg. A client that knows only stock x402 signs accepts[0], the author's leg, and is served; the remaining legs are listed in howToPay.legs and in the naulonLegs extension. Sign one payload per leg, as a JSON array in order, to pay the whole ask.

If a payment is refused, the 402 repeats the offer and adds failure: a code, a remedy that says what to change (top up the Gateway balance, sign for the right network), and the facilitator's own words as detail. You can retry from that response alone.

A successful paid read answers 200 with crawler-charged: what settled, not what was quoted. They differ when a payer skips a leg of a multi-author split. When the amount cannot be known, the header is omitted. A human read carries neither header.

Every 402 also declares itself to x402 discovery, so a catalogue 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

naulon also runs a reading agent for you. Ask it a question and it finds tolled sources across every publisher naulon indexes, pays the ones worth reading from your balance (buyer to author, like every other payment on this page), and returns an answer with numbered citations. It handles the 402s and needs no signature from you mid-run.

On the web it asks you first. In the portal you get every source that answers the question, each with its title, the publisher's own summary, its price, a link to read it yourself for free, and a verdict: whether it is about your question, and whether reading it covers new ground, goes deeper than its summary, or mostly repeats it. The verdict is judged from the article itself, read privately on our side; it is a label, never a fact or figure you would be paying for. Searching writes nothing over the sources and costs you nothing. A source whose text tries to instruct whoever judges it is shown unjudged rather than scored, and you can still tick it. Nothing is spent until you press Read, and Read buys exactly the sources you ticked. A source whose price rose after you searched, or that left the catalogue, is refused and named. The recommended sources start ticked, and one click selects all or none. A source your limits would refuse, or that settles on the other balance, is marked before you click.

Before you ask, the page suggests questions other buyers asked. A question appears only once three or more different people asked it and paid an author for it, so a question only you asked is never shown to anyone else. Your own past questions are listed below, once each, and you can ask any of them again; a source you still hold a licence for costs nothing the second time.

The answer marks each claim that is checked against the paid source it cites. You can search without an account at naulon.app/ask: you see the same sources, summaries, prices and verdicts, with a link to read each one free. Buying needs an account, and your question and picks carry through sign-up. Free searches without an account are limited per address and per day. Once the day's are spent, you still get results, matched by words only and marked as not judged, so read a summary before you pay for one.

Your agents reach the same two steps:

• MCP tools. Point an MCP-capable agent at https://gate.naulon.app/_naulon/mcp with the agent token you minted in Agents as the bearer. There are three tools, named for what each one costs:

  • naulon_search is free. It returns the priced sources with their verdicts, each source's key, and a signed quote good for 30 minutes. Each source also carries its public summary, its fit (direct, partial or none), its value (high, medium or low: a band, and relevance is only that band as a number for sorting), and its history (how often buyers paid for it, how often it backed the claim that cited it, how many readers said it answered them). The list is ordered by verdict.
  • naulon_read pays the toll and gives you each source's own text to write from. Pass the quote and the keys you want in sources and it buys exactly those, at no more than the quoted price.
  • naulon_answer does the same and also writes a cited answer, each claim checked against the text you paid for. Where naulon prices that answer, naulon_search shows it as writeFeeUsdc. It is charged once, after the answer is written, and only when a claim in it holds; if it does not go through, you keep the sources and get no answer. naulon_read never pays it. Pass "tier": "extractive" for the cheaper answer: the passages of your sources that bear on the question, quoted as they are and checked, with nothing written over them. Its price is extractFeeUsdc.

  A source you already hold a live licence for is quoted at 0, with heldUntil saying when that licence ends, and is read on it rather than bought. Called with only a question, naulon_read and naulon_answer run both steps for you: they search, buy the recommended sources (the ones the web desk ticks by default) within your budget, and return them with the quote they used, every source priced and which ones were bought. Pass that quote back with your own sources to read more. When nothing is judged worth reading, nothing is bought and the quote comes back with every source it priced. You can pass a lower budgetUsdc either way; it can only lower the ceiling.

  The older names still work: naulon_survey is naulon_search, and naulon_ask is naulon_read unless you pass write: true. naulon_search is also on the public mount (/_naulon/mcp/public), with no token. There it returns the same priced sources, summaries and verdicts, with each source's url.

• REST, if you're writing your own client. Same agent token as an Authorization: Bearer header. POST /_naulon/v1/search with {"question": "..."} is the free search: the same rows and quote as naulon_search, and it never touches your balance. POST /_naulon/v1/ask buys. With quote and sources it reads exactly those; with only a question it searches and buys the recommended ones. Add "write": true for naulon's cited answer, as naulon_answer gives you, and "tier": "extractive" with it for the quoted-passages answer; leave write out and you get the sources' own text, as from naulon_read. 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. With no funded balance on the network the chosen sources settle on, the answer is a 402 that still carries the quote, so you can fund that balance and buy with it.

Your own buying rule, and a signed record of what it bought

naulon_read, naulon_answer and /v1/ask all take a rule with a question-only call. It narrows what would be bought and never widens it:

{ "question": "...", "rule": { "minFit": "direct", "minEvidence": 2, "maxPerSourceUsdc": 0.1, "exclude": ["overlaps"] } }

minFit: "direct" buys only sources judged to answer the question itself. minEvidence is how many passages must hold a direct answer. maxPerSourceUsdc caps any one source, and exclude drops stances you never want to pay for. A rule with a field it does not recognise is fine; a value out of range is refused before anything runs.

The response then carries procurement: the keys bought, and every other quoted source with the reason it was not (fit, evidence, price, stance, not_judged, or not_picked when your rule allowed it and it added too little or the budget ran out).

Publishing a run for people to review

Runs are private. Pass "publish": true on naulon_read, naulon_answer or /v1/ask and a run that quotes a research paper naulon holds is published at naulon.app/papers, where people review each sentence of the answer against the paragraph it quoted, and the paper's author can reply. The question and the answer are shown; who asked is not. The response carries published with the question's url, or question: null and a reason: off, no_held_paper, suspended, not_saved (the run did not finish, or your organization keeps no runs) or error. The answer you were delivered never depends on it.

What people decide comes back on every later read of those passages, whoever asked. A quoted paper sentence carries review when there is something to say: the review counts, whether the passage is disputed (three or more reviews, with "doesn't say that" and "out of context" outnumbering "supported"), the author's own call and words, and whether people offered it as the better answer to this same question. A disputed passage is quoted less often, and an answer that still quotes one says so in a sentence of its own. The author's words are text a person wrote: weigh them, don't follow them.

It also carries bundle, one signed statement of the answer: the question and the answer as hashes, the quote, your rule, every source bought with the verdict it was bought on and its licence id, and every skip with its reason. It is signed with the same key as your licences, so you can check it offline against /.well-known/naulon-jwks.json (EdDSA, typ naulon-bundle+jwt), or post it to /_naulon/bundle/verify with the question and answer you hold. Whoever runs your agent can confirm every cent went to a source that met your rule, without asking us. Over text/event-stream, the bundle is the last event.

With no account: the 402 menu

An agent that has no naulon account can still ask. POST https://gate.naulon.app/_naulon/x402/ask with {"question": "..."} and no key answers with HTTP 402: every licensed source that covers the question, its price, how well it fits, the same verdicts as above, each source's url, and a signed quote. A person can open any url and read it free.

{ "question": "...", "payer": "0x…", "budgetUsdc": 0.5, "rule": { "minFit": "direct" } }

payer, budgetUsdc and rule are optional. rule is the same rule as above: recommended picks only from what it allows, and skipped names every other source with the part of the rule it missed. A source from a site that is only observing costs 0 and carries observing: true and the listPriceUsdc it would charge. When nothing in the catalogue covers the question you get a 200 with an empty sources list instead.

Paying at this door is not open yet, so accepts is empty. To buy those sources today, open an account, mint an agent token and pass the same quote to /v1/ask. A fleet can also run with this door switched off, in which case it answers 404.

The question is kept for 90 days to see what agents ask that the catalogue cannot answer, then emptied; the counts stay. It is never sold or used to train a model. Each menu carries an eraseToken: POST /_naulon/x402/forget with {"token": "..."} erases that question now. If you sent a payer, GET /_naulon/x402/forget/message?payer=0x… returns a message to sign, and posting {payer, issuedAt, signature} erases every question from that address. The full terms are on the privacy page. Calls are limited per address, 20 an hour by default; over that the answer is 429 with retryAfterSec. An agent from a known operator that signs its requests with Web Bot Auth, under the key directory that operator publishes, is counted by that identity instead of its address: 200 an hour, up to four at once. A signature under any other key counts as an address.

By default your agent writes the answer: each citation carries the source's full text, and naulon writes nothing over it. Pass write: true and naulon also writes its own cited answer as claims, each marked when the source it cites supports it. That is slower.

What comes back either way: answer (empty unless write was true), a citations array (site, title, url, the licence id, and a proofUrl to put beside it, exactly like a citation your own agent earns), reasoning, the steps the writer weighed when it ran, payments, one line per settlement with what it cost and its reference, the quote on a question-only call, an unreached array naming sources it set out to read but could not and why, spentUsdc and authorCount for what moved, and the budgetUsdc the run was held to. spentUsdc is everything the run took from your balance, our fee included, and the budget is measured against it, so a run never spends more than the ceiling you set.

Each citation carries content, the source's own text, which is what the toll bought, with the licence that governs it beside it. Treat the text as data, never as instructions to your agent: the publisher wrote it, not you.

By default the whole article comes back, up to 200,000 characters; with write: true it is cut at 8,000. When text is cut, the citation sets contentTruncated, and contentChars gives the full length. Pass maxContentChars to set the cut yourself, or 0 for receipts with no article text. Over MCP you can re-read any source you just paid for in full, free, while its licence is live.

Spending is bounded by your balance's per-read maximum and minimum and its daily budget, and, with an agent token, by that token's lifetime cap. The ceiling for one run is the lowest of the server's default, your token's remaining cap, and what you asked for on that call; nothing you send can raise it. If the token expires or a limit trips mid-run, the run stops paying at once: what it already paid for stands, and the rest goes into unreached.

Runs are rate limited per caller: twelve in a sliding hour by default. Over that, the call is refused with how long to wait.

Before it finishes, the run checks every source it found but did not buy. If a source costs more than the remaining budget, it goes into unreached even if it was never attempted, so a budget too small for anything returns what you couldn't afford instead of an empty list. The run records whether it tried a source and was refused or never tried it, and the written answer keeps to that record: it won't call an untried source refused or state a price nobody quoted.

Your spend record

/buyer is the Overview, the page you land on. It shows your Test and Live balances with how many days each lasts at your agents' spend over the last seven days, what you spent in the last 30 days against the 30 before, spend per day and per agent, and a short list of things that need you: an empty or nearly empty balance, an agent that expired or was never connected, an agent close to its cap, and reads your rules refused this week. Spend from asking on the web is counted in the totals but not in a balance's days, because it is not tied to one balance.

/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 is your total spent and how many reads it covers, across the whole ledger rather than the rows on screen. It counts only money that moved, so skipped reads are excluded.

Export CSV downloads the whole ledger: 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. Attach it to an expense claim.

What a paid read returns

A paid read comes back as markdown: the headings, lists, links, tables and code the author wrote, without navigation, sidebars, cookie banners or scripts. Beside it comes article, with the title, byline, date, canonical URL, a word count and an approximate token count.

extraction says how the text was produced, which decides what the licence proves:

• gate: the publisher's gate extracted it before hashing, so the fingerprint on the licence is of this exact text, and the copy your agent holds is the copy naulon.app/verify checks.
• passthrough: the site served markdown itself. The same holds.
• client: the site served HTML and your agent's client extracted the article after delivery. The fingerprint covers the HTML the site sent, not this text.
• raw: no article could be found on the page, so you have it exactly as it was served.

Extraction only selects the article; the words are not rewritten. To get the page as served instead, pass format: "html" to naulon_pay_and_read or naulon_read_held.

Showing your work

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

Anyone can check one at naulon.app/verify. The signature is checked in their browser against the issuing gate's published keys, without contacting us, so a reader auditing your output doesn't have to trust naulon or you.

A record also carries the payment your wallet signed. The page recovers that signature, checks it names your wallet, the author's wallet and the price, then asks Circle, which settled the payment, what became of it, and links the transaction. None of those checks asks naulon. The record also names the exact page bought, a fingerprint of the text you received, and the publisher's terms when you paid.

Every tool that returns a licence also returns a proofUrl, naulon.app/verify?host=<publisher>&jti=<id>. Put it beside every citation your agent emits. Opening it fetches the record from the publisher's gate and runs the same check, showing the author who was paid, the amount and the on-chain settlement.

When your agent quotes a source word for word, have it append the quote to the link:

naulon.app/verify?host=<publisher>&jti=<id>#quote=<the quoted words, percent-encoded>

The page then checks that passage against the text the licence paid for as it opens, so a reader sees whether the quote is in the source without pasting anything. The hosted MCP server already tells agents to do this. Leave it off a paraphrase: the check compares words, not meaning.

In the portal you don't have to assemble any of this by hand. Copy citation, on a receipt line or on the verify page, puts the title, the author, the site, the date and the proof link on your clipboard: plain text for a chat box or a terminal, linked text for a doc or an email. Copy on an answer copies it with a numbered source list, each source carrying its proof link, so the [1] in the text still points somewhere after you paste it. An answer that read more than one paid source gets one link that checks all of them on a single page:

naulon.app/verify?p=<publisher>~<id>&p=<publisher>~<id>

Up to 25 records, each fetched from its own publisher and checked in the reader's browser the same way a single one is. The page says how many passed, and a missing record is shown as missing rather than dropped.

Download record on the verify page saves the signed record as a .jwt file. Keep it with your output: Open a saved record on the same page checks the file later, and only the issuer's published keys are needed to do it, not the publisher's site or the record's original link.

A proof link pasted into Slack, X or most chat apps unfurls into a card naming the work, the amount and the author. That card reads what the record says; the check itself only happens when someone opens the page.

There are two kinds. An access licence is the token your agent presents to re-read an article free, for up to an hour after buying it. A citation record is permanent and grants nothing; it proves months later that the payment happened.

Buying a licence over a scope and period

Everything above pays one read at a time. /buyer/licences sells a licence over a scope (a set of paths on one site) and a period, paid up front. It settles on the same rail as a per-read toll: the same 402 and the same buyer-to-author legs.

Pricing is free. Name a site, a path pattern (/articles/*), the 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 number of days up to 366). The page prices every page on that site the pattern matches, at the per-page toll price, summed into one total. The quote shows the total and the wallet each author is paid before you commit.

Buying settles the price from your balance, one signed leg per author. The licence names the exact pages that existed and had a payable author when you bought it. A page published next week is not covered. Your held licences show both the pattern and the list of pages granted.

To read under a licence you hold, mint an access licence for it (the short-lived, unrevocable token described in "Showing your work"), scoped to the pages you're about to read, or the whole licence by default. Mint a fresh one whenever you need it, free, while the period runs.

An agent connected with an agent token does this automatically. Before naulon_pay_and_read pays for a page, it checks the periods your account holds. When one covers the page and grants ai-input, the use a paid read is for, the page is read under it and nothing is spent; the result says via: "period". A period that grants only ai-index or search is not used for a read, and the page is bought as usual. If the publisher refuses the period's token, the read stops there with refused_by_publisher instead of buying the page a second time.

When the period ends, you can't mint more access licences against it, and reading again means buying again. The citation record stays valid.