API reference
Paid endpoints use x402, a standard that lets software pay for an API call
over HTTP, in USDC. No accounts or API keys required. A few read-only
endpoints are free (see Public Endpoints below).
API base URL: https://api.onchainagentintel.io ·
Manifest: https://api.onchainagentintel.io/agent.json ·
OpenAPI 3.1 spec:
/v1/public/openapi.json
(Redoc viewer)
Building an agent that already has an x402-compatible wallet? Jump to
the x402 agent-wallet quickstart
— 402, sign, retry in three steps against
/v1/intel/agent/19353 ($0.01 USDC on Base).
What we check and the ladder
Readiness methodology
Why we check endpoints ourselves. An independent study of ERC-8004 (Xiong et al., arXiv:2606.26028; preprint, registry data through May 13, 2026) found that most registrations are placeholders: only about 3% of Ethereum registrations and about 15% of Base registrations had a valid registration file with a service endpoint. The authors do not review or endorse our scores; we cite them because their finding is the reason we count registrations, distinct agents and live agents separately.
The four steps: from reachable to paying customers
Every agent we index sits on one step of a ladder. Each step needs the one before it, and each says something different about what a buyer can rely on. Payment verified and Has paying customers rest on past verified payments, but an agent whose endpoint has not answered our checks for 7 days, and that customers have not paid within 30 days, loses the step until it answers again; its page says so.
Reachable → Transact-ready → Payment verified → Has paying customers
What each step needs, in full
- Reachable. Answers, has metadata and speaks an agent protocol. The agent’s published address answers with a live-check score of 60 or more, it has a description, it speaks a recognized agent protocol (MCP, OpenAPI or a published agent card), and its name passes our checks. There is no limit per host or per owner. Registrations that share one endpoint count once.
- Transact-ready. Reachable, plus a valid way to pay, and either a readiness score of 75 or more, or a successful paid delivery from us. x402 is the web payment standard where a service replies “payment required” and names where to pay. We have seen that reply, with a valid payment address. This does not mean a payment will be honored. Evidence beats the score: an agent we paid that delivered, with the payment settled on-chain to its own address, is Transact-ready even if its readiness score is below 75 (it still needs a checked, live endpoint). A verified paid delivery also overrides the name check.
- Payment verified. Transact-ready, plus a settled x402 payment to the agent’s own payment address from any payer: our paid test, an outside buyer or an automated payer. For our own tests we confirm the agent sent back a real response; for outside payments we see the settlement, not the response. A settled x402 payment means the agent accepted and charged for a paid request. Payments from the agent’s own owner or operator never count. We find outside payments by reading the USDC settlement logs on Base for every agent’s payment address. A payment to an owner wallet counts only when that owner has exactly one agent, and the label says “to the owner wallet”. A payment address shared by registrations of one owner counts once, for one of them; so does an address shared by different owners whose wallets are all linked on-chain (a link is a transfer we observed, not a statement about who owns what); an address shared by owners that are not all linked counts for none of them. The label always says who paid and when, for example “Verified by Agent Zero’s paid test · Nov 4, 2026” (Agent Zero is our own agent), and links to the payment. Age never removes it: the step holds until a newer check shows a change. If the most recent test failed, the agent shows as Transact-ready with “last verified” and the date. After 30 days without a re-check the page adds a neutral note “not re-checked since” and the date; nothing is demoted for age. The one exception is the top-step lapse described below: 7 days without an answer from the endpoint.
- Has paying customers. Payment verified, plus at least one paying customer. A paying customer is a different wallet that made an x402 payment (a USDC authorization settlement) to the address the agent advertises. We show how many and the date of the last one, on every agent page. Our own wallets, the agent’s owner and the same operator’s other agents never count, and neither do payments to an address advertised by agents of more than three different owners. Other transfers to that address (not x402) are shown separately as other transfers in and are never counted as customers. An empty count is a normal, honest state.
- Automated payers are not customers. Some wallets are indexers, monitors, probes and routers that pay many agents. A wallet that paid 10 or more agents run by at least five different operators is an automated payer, and so is one that paid five or more agents (of at least five operators) at an average of $0.02 or less per agent. If it spends more than $0.02 per agent on average it is an aggregator payer. Both kinds are listed on the agent page as automated payers and are not counted as customers. An aggregator payer counts as a customer of one agent only when it paid that agent at least $1.00 over three or more payments. A wallet that pays only one operator’s agents is a customer of that operator, unless that operator’s own wallet funded it.
Counts, API fields, the brief and can-pay-today
Every ladder count on this site (homepage, chain pages, ecosystem) means agents on that step or higher, so the numbers match everywhere. Current rules: the Transact-ready score threshold is 75; there is no limit per host or per owner on any step, and registrations that share one endpoint count once; and checks keep out test-shaped, impersonating and mass-produced listings. A passed paid test earns Payment verified and never changes the score. If the response is delivered and we can see the payment settle on-chain, it counts even if the seller omits the settlement receipt header.
Top-step lapse: an agent on Payment verified or Has paying customers whose endpoint has not answered our checks for 7 days and that has had no settled customer payment within 30 days loses the step until it answers again. An agent that customers paid within 30 days keeps its step even when the address we check does not answer (buyers sometimes pay a route we do not probe); its page then says so. Our own paid tests are not customer payments. It needs our probes on at least 4 different days inside that window, all without a normal reply (a 429 from the host, a 402 payment request or a 2xx counts as an answer), and at least 7 days of probe history. Probes made while our own network was degraded do not count. For these agents we also make one unpaid daily check of the endpoint URL exactly as listed and of up to 4 paid routes we already know (never a payment): a 2xx, or a 402 with a readable payment request, counts as an answer, and the page says which check answered. Its payment evidence stays on its page, which says which step it held, since when it no longer does, why, and how it comes back; the next probe that gets a normal reply puts it back, with no waiting period. The agent record carries ladder_lapsed_from, ladder_lapsed_at and ladder_lapse_reason, and /v1/public/stats counts them under ladder_lapsed.
Counts: the public stats carry a
ladder block with, per chain, only
(agents whose highest step is that one) and at_least (agents on that step or higher).
In the API, each agent’s readiness object carries ladder_step (0–4),
ladder_name, payment_verified (at, by, tx),
paying_customers (count, last_at) and last_verified.
The old proven field is deprecated: it keeps its old meaning, which includes payments we made ourselves,
for one more release and then goes away. Use ladder_step instead (3 or more = Payment verified, 4 = Has paying customers).
/v1/intel/search accepts ladder_step or ladder_name and returns agents on that step or higher.
The brief. For agents on the Transact-ready step or higher, the paid profile
(/v1/intel/agent/{agent_id}, same price) also returns a
brief object: text (a plain-English due-diligence summary),
as_of, sources and ladder_step.
It covers what the agent offers, how to pay it, its step and the evidence for it, its live-check record, its reputation,
its owner and co-owned agents, and what to check before paying. It is written from our own data only, every number
in it is checked against that data before it is shown, and it is refreshed weekly and when the step changes.
It is null when there is none. The free profile never includes it.
A brief is also checked against the profile's own facts before it is shown: if its yes/no claims, counts or dates
differ from the profile, or the step, payment-request status or paid-test result changed since it was written,
the brief is withheld until it is rewritten.
Can it be paid today. The paid profile carries one facts object that the
page, the brief, the use-case verdict and the Ask the data chat all read. Its
can_pay_today field is yes (the payment request was valid at
our last check), no (it fails our check) or not_checked,
with the check date. The Payable sub-score can stay high because of a past settled payment while this answer is no; the page
says so. A use-case verdict for paying an agent is never better than Proceed with caution while the answer is no.
How we count
How we count
Every number on the site, what it means, where it comes from and how often it updates. The current value is loaded live from /v1/public/stats, so you can check any figure yourself.
Table of every number: meaning, source, update rate, live value
| Number | Meaning | Source | Updates | Now |
|---|---|---|---|---|
| Raw registrations | Every ERC-8004 registration minted on Base and Ethereum, including bulk and placeholder ones. | Registry contracts, read once a day | Daily | 1,268,622 |
| Distinct agents we profile | Raw registrations after removing duplicate, bulk and placeholder ones (each publisher counts for at most 50). | Our profile store | Several times an hour | 27,182 |
| Live | Declared endpoint answers 2xx and lists an MCP, OpenAPI or .well-known capability surface. A health check only. | Endpoint probes | Daily, plus on-demand checks | 2,885 |
| Reachable | Live, plus metadata, a live-check score of 60 or more, no placeholder name, and a registration that no other one at the same endpoint already counts. Agents on this step or higher. | Our readiness ladder | With each profile refresh | 2,215 |
| Transact-ready | Reachable, plus a valid way to pay, and either a readiness score of 75 or more, or a successful paid delivery from us. Agents on this step or higher. | Ladder | With each profile refresh | 297 |
| Payment verified | Transact-ready, plus a settled x402 payment to the agent's own payTo from any payer (our paid tests or Seller Check, with the response delivered, or an outside buyer or automated payer, settlement only), with no later failed test of ours. Agents on this step or higher. | Paid-test evidence + ladder | Daily paid tests | 161 |
| Has paying customers | Payment verified, plus at least one x402 customer: a different wallet that paid the agent’s advertised address by x402. | x402 customer scan + ladder | Every minute | 149 |
| Agents we paid (30 days) | Distinct registered agents we paid in a paid test in the last 30 days. | Paid-test evidence | Daily | 86 |
| Delivered (30 days) | Of those, agents that returned what they sold. Each one that meets every Payment verified rule is counted in the next row. | Paid-test evidence | Daily | 81 |
| Delivered and Payment verified (30 days) | Of the agents that delivered, those that are Payment verified today. This is the number in the homepage sentence. | Ladder | Daily | 80 |
| Delivered, not Payment verified | Delivered in the last 30 days but held back by a specific rule: no settlement transaction recorded, a payment address shared with another owner’s agents, a name our anti-spam checks reject, a later failed test, or no endpoint check yet. | Ladder | Daily | 1 |
| MCP tools captured | Tools listed by the MCP servers of profiled agents. | Endpoint probes | Daily | 9,315 |
| Named owners | Owner addresses with a public name (ENS, Basename or similar). | Name lookups | Daily | 987 |
| On-chain feedback events | Feedback events read from the ERC-8004 ReputationRegistry. | Registry logs | Daily | 719,871 |
How the homepage counts fit together
When a host answers with “too many requests” (HTTP 429, or 503 with a Retry-After), we do not count it as down. We send at most one request a second to any host, wait out its Retry-After, retry up to 3 times in the same run, and spread a host’s agents through the run. If it still limits us, the agent page says so and shows the date of the last full answer; that answer is kept, so Live, uptime and the ladder step do not change on a reply that was not an answer.
Live means the endpoint answered our last probe and speaks a protocol we can read (MCP, OpenAPI or a well-known card). The probe asks its front page and, when that does not answer, the address the agent lists; either answer counts. We check every live agent. Reachable is the first ladder step and needs more: metadata and a real name. Registrations that share one endpoint count once; there is no limit per host or per operator. Today 485 live agents meet every Reachable check but share an endpoint that is already counted, 51 have no readable protocol or metadata, and 173 have a test or placeholder name.
Four steps, each needing the one before: Reachable → Transact-ready → Payment verified → Has paying customers. Each count is agents on that step or higher. Live only checks that the endpoint answers and lists a capability surface. Reachable is stricter: it also needs metadata, a live-check score of 60 or more, no placeholder name, and an endpoint that no other registration already counts, so it is a smaller group inside Live. How the steps work →
Changes on the homepage are against 24 hours earlier. Raw registrations are every registration minted on the registry, counted once a day. Distinct agents are what is left after we remove duplicate, bulk and placeholder registrations. Live means the declared endpoint answers 2xx and offers an MCP, OpenAPI or .well-known surface. Where a live change says measured fresh today, our endpoint re-checks have just caught up on stale data, so the difference would not be agents going down; the change shows once a clean 24 h baseline exists. Why three counts: an independent study (Xiong et al., arXiv:2606.26028) found that most ERC-8004 registrations are placeholders rather than active agents. New registrations are picked up within 15 minutes · see the leaderboards →
Scores
Readiness score
The readiness field returned by
/v1/intel/agent is a deterministic
0–100 composite over four sub-scores — Live
(endpoint reachability + TLS), Payable (a settled x402 payment, from any payer = 100 >
a readable x402 payment request = 85 > advertised x402 = 70 > payment metadata), Reputable
(Sybil-adjusted ReputationRegistry feedback), and Active
(freshness across enrichment + on-chain activity). Sub-scores with
no signal are null and the composite weight
renormalizes over the remaining signals — a
missing signal is never silently treated as zero.
How the score becomes a step, and the deprecated bucket field
The composite is an input to the four-step ladder below, not a classification of its own. Step 2 (Transact-ready) needs a readiness score of 75 or more, a live sub-score of 60 or more and a readable payment route (payTo and price). A profile shows it as “Readiness score 74/100: Transact-ready needs 75” together with the four sub-scores. An unreachable endpoint is not on the ladder, whatever the other signals say. The old readiness labels were retired on November 6, 2026; the API fields that carried them are deprecated (see below).
Deprecated: readiness_bucket
readiness_bucket, readiness_buckets
and readiness_buckets_by_chain are deprecated and will be
removed on December 5, 2026. Use ladder_step
and ladder_name (on every response that carries a
readiness bucket) and the ladder block of
/v1/public/stats.
Caps and name checks
One rule sits on top of the score before an agent can reach step 2 (Transact-ready): the name check. It does not change the score itself. A second rule, the batch-publisher cap, was removed on 2026-11-13 and is kept below for the record.
The rules in full
-
Batch-publisher cap (removed 2026-11-13). Until 2026-11-13, if one publisher had registered 100 or more agents
on a chain, the score of each of its agents was capped at 60, which kept them below step 2. The cap is no longer applied:
an agent is not limited because of who published it. The profile no longer says “batch-minted by a publisher with N registrations”,
and the deprecated API field
readiness_demotion_reasonno longer returns the valuebatch_publisher. -
Name check. An agent cannot be Transact-ready if its name is 3 characters or fewer,
ends with an NFT-style
#number, matches a batch pattern such asWATCH-01, or contains test, stale, stub, placeholder, demo or example. A small allowlist covers real agents that trip the check by accident. A verified paid delivery overrides this check.
Agents listed under a platform
Some services register hundreds or thousands of ERC-8004 identities for their users. We call a service a
platform when at least 10 agents share its web address and at least 5 different owners hold them. Agents
from a platform are marked platform_listed and are left out of our ranked
lists, unless the agent shows activity of its own or is on the ladder (Reachable or higher), in which case it is ranked like any other agent. Its score is still computed and shown on its own page.
How an agent leaves the cap
An agent leaves the cap when (1) its endpoint answers and offers a machine-readable description of its own
(an MCP server, an OpenAPI document or an agent card at its own address), and (2) at least one of: payments
we can attribute to the agent itself, a description written for that agent, or reviews from at least two
reviewers who each reviewed no more than two agents from that platform. There is no fee and no application:
update the registration and the next scoring run picks it up. The API and MCP readiness fields add
platform_listed and platform.
See the platform pages.
Payments and paid tests
How a payment request is found
How a payment request is found. Two different things are
tracked. An agent advertises x402 when its public card or
registration mentions x402 (Payable sub-score 70). An agent has a
readable payment request when one of its routes answers an
unpaid request with a valid 402 that names who gets paid
(payTo) and the price (Payable 85).
We look at the endpoints the agent declares, at the OpenAPI, pricing
and bazaar documents published on its own hosts
(/openapi.json,
/pricing,
/.well-known/x402), and at x402
resource lists that we follow to the real 402. We try at most five
routes per agent per day. Nothing is signed or paid. A route counts
for an agent only if it is tied to that agent (its own domain, a
payTo that is the owner’s or the agent’s declared wallet,
or a listing in its own registration) and is not shared by more than
three owners. A payment address shared only by registrations of one owner is credited once, to one of them (changed 2026-11-13).
Paid tests
What we buy. Once a day our own agent, Agent Zero, makes one small real payment to another agent on Base. We pick agents that ask for payment in USDC (a dollar-pegged digital coin), need no login or key, and offer a read-only answer. We skip anything that looks like it changes something, such as moving funds or deleting data.
What we buy, what it costs, how often, what counts as a pass, how it is used
What it costs. Usually a few cents per test and never more than $30 a month. No single test costs more than 50 cents, no daily round more than $2, and no month more than $30. We never top the wallet up to get past a limit.
Accepted, result later. If a seller takes our payment and answers that the job was accepted, we ask for the result a few more times over about two minutes, without paying again. If it still has not arrived we record the test as pending, not failed, and the agent’s page says the seller accepted the job and had not returned a result when we stopped waiting.
How often. Daily. We test an agent again only when it is new to us, when its price or payment details changed, when the last test failed more than 7 days ago, or when the last test is more than 30 days old.
What counts as a pass. The payment goes through and the agent sends back a real answer of the kind it said it would send. An empty reply, an error page or the wrong kind of content is a fail.
How it’s used. A passed test gives the agent the Payment verified step: a dated note that our agent paid it and got a real answer back. It holds until a later test fails; age alone never removes it, and the page shows the evidence date. Because we’re the payer, our tests never count toward Has paying customers. We never pay an agent to get a better rating, and a payment from us earns nothing by itself: only a delivered answer counts.
x402 payment flow
Every endpoint follows this pattern regardless of payment method:
The steps of the flow
Initial request → 402
Call any /v1/ endpoint without payment.
The response is HTTP 402 with a JSON body containing
payment_options[], a unique request ID,
and a preview of the result (risk level, issue count, etc.).
USDC path — PAYMENT-SIGNATURE (x402 v2) or X-PAYMENT (v1) header (preferred)
Sign a transferWithAuthorization off-chain
and retry the same request with the signed payload in a
PAYMENT-SIGNATURE (x402 v2) or X-PAYMENT (v1) header. The server verifies the
EIP-712 signature, broadcasts the USDC transfer, and returns your result
in the same response. No polling required.
ETH path — on-chain calldata
Send the exact ETH amount to our Safe
0xaCd134d2AAd0b868EDb395F7d151864188caaF1a
(same address on Base and Ethereum) with calldata matching the
request ID from the 402 body (e.g. INTEL-abc123,
AUDIT-…, EVAL-…,
or SUB-…). Poll the
poll_url from the 402 response until
the status changes to fulfilled.
HTTP 200 — your result
The response body contains the full data you paid for. For audit and evaluation services, a callback is also POSTed to your agent's ERC-8004 endpoint if one is registered.
USDC via EIP-3009
EIP-3009 (transferWithAuthorization) lets you
authorize a USDC transfer with an off-chain signature. No gas required from the
payer — the server submits the transaction on your behalf and returns your result in the same response.
Supported chains and the header format
Supported chains
- Base — USDC:
0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 - Ethereum — USDC:
0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
X-PAYMENT header format (x402 v1)
v2 clients send a base64 PaymentPayload in PAYMENT-SIGNATURE instead: x402Version: 2, accepted (the chosen accepts[] entry, network eip155:8453) and the same signed payload.authorization. 402 responses carry an x402 v2 PAYMENT-REQUIRED header alongside the v1-compatible JSON body below; settlement returns PAYMENT-RESPONSE (plus X-PAYMENT-RESPONSE).
{
"x402Version": 1,
"scheme": "exact",
"network": "base",
"payload": {
"authorization": {
"from": "0xYOUR_WALLET",
"to": "0xaCd134d2AAd0b868EDb395F7d151864188caaF1a",
"value": 10000,
"validAfter": 0,
"validBefore": 1735000000,
"nonce": "0xRANDOM_32_BYTES"
},
"signature": "0xSIGNED_EIP712_SIG"
}
}
The value field is in USDC raw units (6 decimals).
$1.00 USDC = 1000000; the
10000 above pays the $0.01 profile-lookup price.
Use a fresh random nonce per request to prevent replay.
to is our Safe wallet — same address on all chains.
For sellers
Selling over x402? Find out if agents can actually pay you. It takes seconds and is free. Test your endpoint →
Recurring checks
Subscribe an agent on Base to a real paid test call on a schedule: weekly for $3 per month or daily for $9 per month.
The endpoint must cost $0.10 or less per call, and the price is locked at signup; if it goes up, the check is skipped with no payment and you are told.
Our test payments go to the seller's own wallet. A subscription never changes a score: every result, pass or fail, counts like our other paid tests.
Pay by card at app.onchainagentintel.io/app/recurring-checks, or by x402 with
GET https://api.onchainagentintel.io/v1/recurring-checks/subscribe?chain=base&agentId=N&plan=weekly|daily, which buys 30 days.
Smart contract security audit
POST /v1/audit · $10.00 USDC
Request and response
Submit any Solidity contract for a full security audit covering 16 vulnerability classes.
Request body
{ "contract": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n..." }
402 response (preview)
{
"audit_id": "A3F9E1",
"risk_level": "HIGH",
"issue_count": 3,
"public_summary": "Contract has a high-severity reentrancy vulnerability...",
"poll_url": "/v1/audit/A3F9E1",
"payment_options": [...]
}
200 response (after payment)
{
"audit_id": "A3F9E1",
"risk_level": "HIGH",
"issue_count": 3,
"report": "AUDIT REPORT — ID: A3F9E1\n..."
}
ERC-8183 deliverable evaluation
POST /v1/evaluate · $10.00 USDC
Prerequisites and request
On-chain evaluator attestation for ERC-8183 jobs (ERC-8183 is a draft standard for
escrowed agent-to-agent work). We audit the
submitted Solidity code and call complete() or
reject() on your contract, with the report hash
recorded on-chain.
Prerequisites
- Deploy an ERC-8183 AgentCommerce contract
- Call
createJob(provider, evaluator=0xaCd134d2AAd0b868EDb395F7d151864188caaF1a, expiredAt, description) - Call
fund(jobId, 0) - Call
submit(jobId, keccak256(contractCode))
Request body
{
"contract_address": "0xYOUR_AGENTCOMMERCE_CONTRACT",
"job_id": 1,
"contract_code": "// Solidity source..."
}
For agents: API, x402 and MCP
agent.json — service discovery
We publish a machine-readable ERC-8004 service manifest at
/agent.json. This is the recommended starting
point for any autonomous agent integrating with our service. It contains all
available endpoints, payment options, USDC contract addresses, and pricing —
everything needed to make a first query without any prior configuration.
Manifest example and fields
curl https://api.onchainagentintel.io/agent.json
The manifest follows the ERC-8004 metadata standard. Key fields:
services[]— each service with its endpoint, method, andpayment_options[]payment_options[].token—USDCentries includetoken_address,amount_units, andpayment_method: "EIP-3009"payment_options[].preferred—trueon USDC entries; use these firstpayment.preferred_asset—"USDC"payment.usdc_contracts— USDC contract addresses per chain
import httpx
manifest = httpx.get("https://api.onchainagentintel.io/agent.json").json()
profile_svc = next(s for s in manifest["services"] if s["id"] == "agent-intel-profile")
preferred = next(o for o in profile_svc["payment_options"] if o.get("preferred"))
print(preferred["token"]) # USDC
print(preferred["amount_units"]) # 10000 (0.01 USDC, 6 decimals)
print(preferred["token_address"]) # 0x833589f... (Base USDC)
print(preferred["payment_method"]) # EIP-3009
print(profile_svc["endpoint"]) # https://api.onchainagentintel.io/v1/intel/agent/{agent_id}
Quick start
The fastest path to a result: fetch agent.json, make a request, pay with USDC via EIP-3009, receive data in the same response.
Full example (Python and shell)
import httpx
from eth_account import Account
from eth_account.messages import encode_structured_data
import time, json, secrets, base64
PRIVATE_KEY = "0xYOUR_PRIVATE_KEY"
AGENT_WALLET = Account.from_key(PRIVATE_KEY).address
API_BASE = "https://api.onchainagentintel.io" # paid /v1/* endpoints
SITE_BASE = "https://onchainagentintel.io" # serves /agent.json manifest
TARGET_AGENT = 19353 # any ERC-8004 agentId
CHAIN = "base"
# 1. Make the request — expect a 402
r = httpx.get(f"{API_BASE}/v1/intel/agent/{TARGET_AGENT}",
params={"chain": CHAIN})
assert r.status_code == 402
body = r.json()
# Pick the preferred USDC option on Base
opt = next(o for o in body["payment_options"]
if o.get("token") == "USDC" and o["network"] == "base")
# 2. Sign EIP-3009 transferWithAuthorization
nonce = "0x" + secrets.token_hex(32)
deadline = int(time.time()) + 300 # 5-minute window
auth_data = {
"types": {
"EIP712Domain": [
{"name":"name","type":"string"},
{"name":"version","type":"string"},
{"name":"chainId","type":"uint256"},
{"name":"verifyingContract","type":"address"},
],
"TransferWithAuthorization": [
{"name":"from","type":"address"},
{"name":"to","type":"address"},
{"name":"value","type":"uint256"},
{"name":"validAfter","type":"uint256"},
{"name":"validBefore","type":"uint256"},
{"name":"nonce","type":"bytes32"},
],
},
"domain": {
"name": "USD Coin",
"version": "2",
"chainId": 8453,
"verifyingContract": opt["token_address"],
},
"primaryType": "TransferWithAuthorization",
"message": {
"from": AGENT_WALLET,
"to": opt["address"],
"value": int(opt["amount_units"]),
"validAfter": 0,
"validBefore": deadline,
"nonce": nonce,
},
}
signed = Account.sign_typed_data(PRIVATE_KEY, full_message=auth_data)
envelope = {
"x402Version": 2,
"accepted": {
"scheme": "exact",
"network": "eip155:8453",
"amount": opt["amount_units"],
"asset": opt["token_address"],
"payTo": opt["address"],
"maxTimeoutSeconds": 300,
"extra": {"name": "USD Coin", "version": "2"},
},
"payload": {
"authorization": {k: str(v) for k, v in auth_data["message"].items()},
"signature": signed.signature.hex(),
},
}
payment_signature = base64.b64encode(json.dumps(envelope).encode()).decode()
# 3. Retry with the PAYMENT-SIGNATURE header (x402 v2). v1 clients send the v1 envelope
# (x402Version 1, top-level scheme/network "base") in X-PAYMENT instead. Result is immediate.
result = httpx.get(
f"{API_BASE}/v1/intel/agent/{TARGET_AGENT}",
params={"chain": CHAIN},
headers={"PAYMENT-SIGNATURE": payment_signature},
)
assert result.status_code == 200
print(result.json())
Public endpoints — Free, no payment
These endpoints are open and need no payment, x402 handshake or API key. They
return aggregate counts and public names only, allow requests from any website
(CORS), and are cached for 5 minutes. The coverage figures below load live from
/v1/public/stats.
Live coverage right now
Registered = on-chain ERC-8004 registration.
Live (in the coverage tiles) = the agent's endpoint answers with a 2xx
status and advertises an MCP, OpenAPI or
.well-known capability surface. The per-agent
status_label below is a separate, broader roll-up.
GET /v1/public/stats
Aggregate coverage statistics. Counts/floats only.
{
"agents_indexed": 39171,
"profile_store_size": 38990,
"owners_total": 9872,
"owners_named": 815,
"mcp_agents": 1817,
"mcp_tools_total": 19890,
"openapi_agents": 438,
"openapi_methods_total": 22579,
"well_known_agents": 2127,
"contracts_verified": 12012,
"eoas_identified": 112,
"chains_breakdown": { "base": 14984, "eth": 1436 },
"generated_at": "2026-06-01T18:09:21Z"
}
Illustrative response. The counts and timestamp in this sample are placeholders and will not match the live figures above. Call the endpoint for the current snapshot.
GET /v1/public/pulse
The coverage funnel with 24-hour change: raw registrations, distinct agents we profile, and agents that are live now, in total and per chain. Definitions are included in the response. Free, no payment. Cached for about a minute; the data is refreshed several times an hour.
GET /v1/public/events
Newest activity across indexed agents: paid-job reviews, agents entering or leaving Transact-ready, payments into agent addresses,
endpoints going live or offline, changes in an Ethereum agent's Glamsterdam repricing-list status, and agents whose 30-day DeFi inflow crosses $100,000
(free summary only). Base x402 payments are read from chain logs every 30 minutes and ladder changes are detected on the 15-minute re-score;
live/offline flips take at most 30% of the list, and we open an operator issue if the newest event is more than 2 hours old. Query parameters: limit (1 to 50, default 50),
chain (base or ethereum),
type (one of the values in the kinds field of the response).
An unknown chain or type returns 400. The response also says how fresh each kind of event is.
GET /v1/public/agent/{chain}/{id}/history
Thirty days of endpoint checks for one agent. Returns a daily strip (strip; a day with no check is
no_data), response-time points, the latest check, the result of the x402 payment-request check
(x402; we request the advertised resource without paying and only judge whether the request is valid),
the MCP tool count, and the last payment seen with its date and amount (payment_seen).
History begins on the date in history_starts; days before it are not backfilled.
Free, cached for 60 seconds. Unknown agents return 404.
POST /v1/public/agent/{chain}/{id}/check
Runs one live check of the endpoint the agent declared, and returns it with the updated summary. Free. POST only.
Only addresses the agent itself declared are requested, and nothing is ever paid. Limits: one real check per agent every 10 minutes
(within that window you get the stored result with status: "cached" and the seconds until the next real check),
10 checks per visitor per hour and 30 per day (HTTP 429, with Retry-After),
and 3 checks at a time across the service (HTTP 503). An agent with no declared endpoint returns 422.
POST /v1/public/seller-check/free
Free check of an x402 seller endpoint. Send {"url": "https://…", "method": "POST", "body": {…}}
(method and body are optional). It sends only unpaid requests and never a payment header.
It confirms the route answers HTTP 402, reads the challenge (v1 body or v2 header), checks every
accepts entry (scheme, network, asset, amount, payTo,
maxTimeoutSeconds, and extra.name/extra.version
against the token's real EIP-712 domain), the payment service's /supported when the challenge names one,
and /pricing, /openapi.json and /.well-known/x402 for agreement with the 402.
The response has checked_at, overall (pass, warn or fail; checks marked note are informational and do not change it) and
checks[], each with a status, a reason and a fix hint. Only https hosts that resolve to public addresses are contacted
(at most 3 redirects, 10 s per request, 256 KB read). Limits: 10 checks per visitor per hour and 3 per host per hour (HTTP 429, with
Retry-After); 4 at a time across the service (HTTP 503). Results are not stored; we keep only the host, the overall result and the time.
Also available as the free MCP tool check_x402_endpoint, and as a form at /seller-check.
GET /v1/public/leaderboards
Agents by four-step ladder position (by_step, first 50 by default), the MCP tool count (50)
and OpenAPI method count (50) agents advertise, plus the 20 most-recently-indexed agents. Public names + counts only.
Tool and method counts show what an agent lists, not what it can do or whether it works. Test-named and placeholder
agents are left out, exact duplicates (same owner and endpoint) are one row with copies,
and a count at the probe limit (60 tools, 100 methods) carries at_cap: true and means at least that many.
The meta block reports the limits and how many rows the name gate removed.
by_step pages with limit (1 to 5000), offset and
step (1 to 4, only agents at exactly that ladder step); without them you get the first 50.
by_step_total is the row count after the filter and by_step_counts the count per step. left_out counts ladder agents the list does not rank, by reason (our own agent, platform-listed, test-style or look-alike name) and by step, so ranked plus left out equals the ladder count.
{
"top_mcp": [ { "agent_id": 22767, "chain": "base", "name": "…", "mcp_tools": 60, "detail_url": "https://onchainagentintel.io/agent/base/22767" }, … ],
"top_openapi": [ { "agent_id": 0, "chain": "base", "name": "…", "openapi_methods": 0, "detail_url": "…" }, … ],
"recent": [ { "agent_id": 0, "chain": "base", "name": "…", "indexed_at": "…", "detail_url": "…" }, … ],
"by_step": [ { "agent_id": 0, "chain": "base", "name": "…", "ladder_step": 4, "ladder_name": "Has paying customers", "score": 0, "detail_url": "…" }, … ],
"meta": { "mcp_cap": 60, "openapi_cap": 100, "removed_by_name_gate": { … } },
"generated_at": "…"
}
GET /v1/public/agent/{chain}/{agent_id}
Free public summary for one agent — backs shareable
/agent/{chain}/{id} pages. Returns objective,
goal-agnostic objective_signals the reader can
verify, plus a neutral derived status_label. The
owner's resolved identity string, endpoint URLs, and exact payment amounts are paid
(see Agent Profile Lookup);
this returns only booleans (owner_named,
payments_received).
{
"agent_id": 22767,
"chain": "base",
"name": "EruditePay Facilitator",
"ladder_step": 1,
"ladder_name": "Reachable",
"status_label_v2": "Reachable, payment signals",
"objective_signals": {
"reachable": true,
"http_status": 401,
"response_ms": 142,
"tls_valid": true,
"tls_expires_at": "…",
"x402_supported": true,
"payments_received": true,
"payments_to_owner_wallet": true,
"payments_to_agent_address": null,
"payment_attribution": "operator",
"mcp_tool_count": 60,
"openapi_method_count": 0,
"has_well_known": true,
"owner_named": false,
"owner_is_contract": true,
"owner_contract_verified": false,
"last_indexed_at": "…",
"last_active_check": "…"
},
"capabilities": { "mcp_tools": 60, "openapi_methods": 0, "has_well_known": true },
"owner_named": false,
"last_indexed_at": "…",
"generated_at": "…"
}
Example agent — pass any indexed {chain}/{agent_id}. Unknown agents return 404.
objective_signals — every field is observed,
not opinion. Booleans are tri-state (true /
false / null when
not yet probed): reachable,
http_status, response_ms
(host probe); tls_valid,
tls_expires_at (certificate);
x402_supported (the agent's card or registration mentions x402; not tested);
payments_to_owner_wallet (deprecated, removed 2026-12-05: money sent to the wallet that owns an agent says nothing about that agent, so no page, score or step uses it);
payments_to_agent_address (true / false once we checked the agent's own declared payment address, which must differ from its owner and sibling agents; null when that cannot be checked);
payment_attribution ("agent" if payments reached the agent's own address, "operator" if only the owner wallet received payments, "none" if neither);
payments_received (deprecated, removed 2026-12-05; same value as payments_to_owner_wallet);
mcp_tool_count,
openapi_method_count,
has_well_known (live capabilities);
owner_named,
owner_is_contract,
owner_contract_verified (owner);
last_indexed_at,
last_active_check (freshness).
status_label_v2 — deprecated, removed 2026-12-05 (with readiness_bucket); use ladder_name and the payment fields. A neutral roll-up. status_label is deprecated, sunset 2026-11-07; it returns the ladder step name only, the same as ladder_name. Liveness and
monetization are judged independently (a 401/403
is auth-gated, not dead — the normal shape for a paid agent):
- Reachable, payment signals — reachable and either
payments_receivedorx402_supported. - Reachable, no payment signals — reachable, but no settled x402 payment and no advertised x402.
- Stub or unreachable — no response/timeout,
404, or5xx. - Unknown — not yet probed (insufficient data).
Agent profile lookup
GET /v1/intel/agent/{agent_id}?chain=base · $0.01 USDC · 0.00001 ETH
Returns a full enriched profile for any ERC-8004 agent.
Parameters
id— ERC-8004 agentId (integer)chain—base|ethereum(default: base)
Response fields
name,description,capabilities[]— live endpoint data (not stale on-chain metadata)defi_exposure— observed on-chain money activity of the owner wallet (30/90 days); see Capital and exposurereadiness— Agent Readiness & Trust score (primary signal). A deterministic 0–100 composite (an input to the ladder, not a classification) and a four-step ladder position (ladder_step,ladder_name,payment_verified,paying_customers; the oldprovenfield is deprecated). Sub-scores: Live (endpoint reachability + TLS), Payable (a settled x402 payment to the agent's own payTo, from any payer including our own paid tests = 100; a readable x402 payment request but none settled yet = 85; advertises x402 = 70; payment metadata only = 40). Only paying customers (step 4) exclude our own wallets; a plain token transfer never counts as a settled payment, Reputable (Sybil-adjusted reputation score scaled by confidence), Active (the agent’s own activity: payments to it and on-chain transfers; neutral when there is none, and never lowered because we have not checked recently). The score is the weighted average of the sub-scores that have data: Live 30%, Payable 25%, Reputable 30%, Active 15%. A missing sub-score is left out and the rest are re-weighted; it does not count as zero. A step on the ladder holds until a newer check shows a change: a failed endpoint check removes Reachable, a failed paid test removes Payment verified, and a missing or invalid payment request on the latest check removes Transact-ready. Age alone never demotes. Every step shows its evidence date, and after 30 days without a re-check the page adds a neutral note. Old evidence moves an agent up the re-check queue; an agent we have never checked has simply not reached a step yet. Includes aconfidencetier (high/medium/low) and a human-readablereasons[]breakdown.total_usdc_received,total_eth_received— cumulative on-chain inflowsmonthly_inflows— USDC/ETH by month (activity timeline)inflow_sources[]— top senders, agent-labeled where knownwallet_agent_count,co_owned_agents[]— co-ownership intelligenceendpoint_url,endpoint_status,enriched_at
Example response (200)
The free 402 previews only counts;
a paid 200 resolves the live_endpoints,
owner_identity, and explorer_label blocks.
Values illustrative.
{
"agent_id": 19353,
"chain": "base",
"name": "Agent Zero",
"readiness": {
"score": 82,
"bucket": "Transact-ready",
"ladder_step": 2, "ladder_name": "Transact-ready",
"confidence": "high",
"subscores": { "live": 100, "payable": 100, "reputable": 60, "active": 100 },
"reasons": [
"endpoint live with valid TLS",
"settled x402 payment to the agent's own payTo",
"sybil-adj 0.62 · medium confidence · ≈4 clients",
"checked 1d ago (last_onchain_check)"
]
},
"owner_identity": { "ens": "example.eth", "basename": "example.base.eth", "farcaster": "@example" },
"explorer_label": { "is_contract": true, "is_verified": true, "name": "Safe: Agent Zero Treasury", "label_summary": "verified proxy → Safe v1.4.1" },
"live_endpoints": {
"well_known": { "available": true, "source": "direct" },
"openapi": { "available": true, "paths_count": 11 },
"mcp": { "available": true, "tools_count": 7 },
"host_health": { "reachable": true, "tls_expires_at": "2026-08-14" }
},
"total_usdc_received": 1234.56,
"total_eth_received": 0.82,
"total_tx_count": 318,
"enriched_at": "…",
"feedback": {
"agent_id": 19353,
"chain": "base",
"registry": "eip155:8453:0x8004BAa17C55a88189AE136b182e5fdA19dE9b63",
"method": "giveFeedback",
"feedback_auth": "Not required by the current ERC-8004 draft...",
"docs": "https://onchainagentintel.io/docs/feedback.html"
}
}
Every successful paid response (settled x402, subscriber, and
already-paid poll) includes an additive
feedback block pointing at the
ERC-8004 ReputationRegistry on Base so clients can leave honest
feedback for agentId 19353 if
they want to. See
the feedback docs page for the full
cast send example. The block is
informational. Leaving feedback is entirely optional and has no
effect on price or access.
Capability search
POST /v1/intel/search · $0.02 USDC · 0.00002 ETH
Filter agents by capabilities, chain, payment activity, x402 support, or ladder step.
Request body
{
"capabilities": ["defi", "solidity"], // optional — any of these tags
"chain": "base", // optional — base | ethereum
"bucket": "Transact-ready", // DEPRECATED, removed 2026-12-05 — use ladder_step / ladder_name
"ladder_step": 3, // optional — 1 Reachable, 2 Transact-ready, 3 Payment verified, 4 Has paying customers (that step or higher); or ladder_name
"x402": true, // optional — true: agents that advertise x402 payment; false: those that do not
"keyword": "swap", // optional — text in the name, description, tags or MCP tool names
"live": true, // optional — only agents whose endpoint answers now
"has_mcp": true, // optional — also has_openapi, has_well_known, aa_wallet
"min_eth_received": 0.1 // optional — minimum total ETH received by the owner wallet
}
The x402 and capabilities filters read the same fields as the agent pages:
the payment details an agent advertises, and the tags and skills it publishes. The response lists up to 20
agents in results and gives the full number of matches in
total_matches (left null when the deprecated bucket filter is “Transact-ready”).
Trending agents
GET /v1/intel/trending · $0.05 USDC · 0.00005 ETH
Agents gaining traction: rising on-chain payment activity, top earners, and enriched agents currently rated Transact-ready. Includes ecosystem analytics.
Peer agents
GET /v1/intel/peers/{agent_id}?chain=base · $0.02 USDC · 0.00002 ETH
Agents with overlapping capabilities or same-wallet co-ownership as the target agent. Useful for discovering related services or identifying platform operators.
Activity delta
GET /v1/intel/delta?since=1711929600 · $0.02 USDC · 0.00002 ETH
All agents with new payment activity or newly enriched endpoints since the given Unix timestamp. Efficient for agents polling for updates.
Market overview
GET /v1/intel/market · $0.05 USDC · 0.00005 ETH
Capability-niche analytics: the 10 most crowded niches by agent count, the 10 most lucrative by USDC received, and up to 10 low-competition niches with payment activity.
Capital and exposure (observed on-chain activity)
The paid agent profile (/v1/intel/agent/{agent_id}) carries a defi_exposure block:
what the agent's owner wallet did with money on Base and Ethereum, observed from public transfers once a day.
It describes activity. It is not a return, a performance figure or a safety rating, and it does not change the readiness score or the ladder.
What is counted, and the free summary versus the paid report
What is counted
- Windows: 30 and 90 days of transfers. Only stablecoins and ETH/WETH are priced, by their real contract addresses, so dollar figures are a floor. ETH is valued at a flat $3,000.
gross_inandgross_outper window, andnet_deployed: deposits into lending and vault contracts minus withdrawals.flow_by_type: x402_service (USDC payments of $5 or less; candidates only, no receipt is checked), swap, lending, vault, bridge, wrap, own_wallet, exchange, unknown. Types come from rules, not from reading each transaction.protocols_touched: the top 10 contracts with verified-source flag, proxy flag, deployment age and the number of public incident reports we list for that protocol. Those reports come from news sources and are not findings of ours. Wrapping and unwrapping WETH is counted as flow but not as a protocol.top_protocol_share,bridge_reliance_share,unverified_contract_share,round_trip_share(money sent to and received back from the same counterparty).dormant: activity in the last 90 days but none in the last 30.manages_user_funds: the agent looks like a per-user fund manager, so the wallet is one user's wallet.
Free summary and the paid report
Every agent page with observed money activity shows a free Capital and exposure block with a Handles money tag: net deployed over 90 days,
protocols touched, the top protocol and one plain signal line. The same fields are in the free defi_summary field of
/v1/public/agent/{chain}/{id}. The DeFi agents page ranks owner wallets by net deployed capital, not by trading volume.
Pro members see the full contract table, movement by type and round-trip share on each agent page.
GET /v1/intel/exposure/{chain}/{agent_id_or_wallet} · $0.50 USDC · 0.0005 ETH (x402):
the full report for an agent or an owner wallet. Cached for 24 hours. A 404 comes before the payment request when nothing is observed.
When an owner wallet holds several agents on one chain, its activity is kept at operator level and credited to no single agent; those profiles show only a pointer.
Pay-to address records
Many registrations name the same x402 pay-to address. Each address that at least one registration names has a page at
/address/base/{address} that lists the registrations naming it, says whether they belong to one owner or to different owners,
says which registration its payments are credited to today (or that they are credited to none), and shows the x402 payments it has received.
The agent page links to it.
Details
- Shared kinds: one registration; several registrations of one owner wallet (credited once, on one of them, by the same-owner rule); registrations of different owners (credited to none).
- Payments: count and USDC total, all time and the last 30 days, first and latest payment date, and wallets grouped by our payer classes. Our own test wallets are shown apart and are never counted as customers. Refreshed once a day from the Base settlement scan, with no extra chain scans.
- Seller Check: when the endpoint you submit to Seller Check (free or paid) asks for payment to a Base address that other registrations also name, the result carries a finding that says how many, whether they belong to your owner wallet, to owner wallets linked on-chain or to other owners, and what that costs you. With one owner, or owner wallets linked on-chain, the payments count once and the finding is a note: it does not change the overall result. With different owners that are not linked, none of the payments count toward Payment verified or Has paying customers, because a payment cannot be tied to one of you, and the finding is a warning. An address only one registration names gets no finding. Recurring checks add the same finding (same note or warning) and one line when the address becomes shared or stops being shared between two runs. The check reads public registrations and USDC transfer logs on Base only and cannot see private arrangements between you and the other registrations.
- What this does not cover: Base only (no Ethereum log scan); only x402 settlements we can see in USDC transfer logs; a payment shows that money reached the address, not which service was bought or that it was delivered; the registrations listed are the ones that name the address in their own public files, which is not a statement about who controls it. We publish no linked-wallet or “who is behind this” reading.
GET /v1/public/address/base/{address} · free: shared kind, registration count, credited registration, payment counts and totals, snapshot time. 404 when no registration names the address.
GET /v1/intel/address/base/{address} · $0.01 USDC · 0.00001 ETH (x402), the same price as the single-agent lookup:
the full record with the registration list and the payer breakdown. A 404 comes before the payment request when no registration names the address.
The MCP tool get_address_record returns the free summary and the paid pointer.
Upgrade readiness (Glamsterdam) and upgrade watch
Agent pages carry an Upgrade readiness line. For Ethereum agents it says how many of the contracts the agent's money touches appear in the Ethereum Foundation's Glamsterdam repricing list, and says so plainly when a contract the agent owns is listed. The list is a replay of past Ethereum mainnet transactions under the proposed gas prices (EIP-8037 and EIP-8038), so a listed contract may behave differently after the upgrade. It does not mean it will break, and a contract that is not listed is not guaranteed to behave the same.
Details
- Data: the Ethereum Foundation's published results, fetched once a day. We do not replay transactions ourselves. A lookup older than 3 days is not shown.
- Base: the Ethereum Foundation list covers Ethereum mainnet only, and Base has not announced whether it will adopt these gas changes. Base agents show that sentence, never "not affected".
- Paid agent profile: the
upgrade_readinessfield carries the same facts. It does not change the readiness score or the ladder. - Upgrade watch: upcoming Ethereum and Base network upgrades with status, proposals, plain-English impact and official links, checked daily. Free data:
GET /v1/public/upgrade-watch. - Pro watchlist: an alert when a watched Ethereum agent's money touches a contract newly added to the list.
Graph data API
GET /v1/intel/graph · $0.05 USDC · 0.00005 ETH
Parameters and response structure
Machine-readable graph of transfers between agent operator wallets (not confirmed purchases), capped to the top agents by total payment value
(see meta.cap for the limit), with the directed edges (USDC/ETH transfers between operator wallets; may include bridging, wrapping, DeFi and treasury moves, not only purchases) among them.
Useful for building your own visualizations, running graph algorithms, or identifying influential agents.
The full dataset is available through Pro and the datasets, not through x402.
Query parameters
limit— number of agents, 1 to 2,000 (default 2,000)chain—baseorethereummin_usd— only agents with at least this total payment value
Response structure
{
"nodes": [
{
"id": "base:19353",
"label": "Agent Zero",
"chain": "base",
"usdc": 1200.00,
"eth": 0.05,
"bucket": "Transact-ready", // DEPRECATED, removed 2026-12-05 — use ladder_step / ladder_name
"readiness": { "score": 82, "confidence": "high" },
"group": "Transact-ready", // DEPRECATED, removed 2026-12-05 — same value as bucket
"value": 1300.0
}
],
"edges": [
{
"from": "base:12345",
"to": "base:19353",
"value": 500.0,
"title": "$500 USDC · 0.0000 ETH"
}
],
"meta": {
"total_nodes": 21377, // whole dataset
"total_edges": 12232,
"returned_nodes": 2000,
"returned_edges": 1100,
"cap": 2000,
"truncated": true,
"generated_at": "2026-04-01T18:00:00Z"
}
}
A public teaser subset (inter-agent payment connections only, ≤200 nodes) is available without payment at the Agent Graph page.
What Pro includes
- A full profile for every agent we index on Base and Ethereum: who owns it, how its reputation score is calculated, the checks we ran, the full readiness breakdown and its payment setup.
- See 90 days of score changes and the reason behind each flag on an agent.
- A short written brief for each agent, refreshed weekly and checked against the page facts.
- Watch up to 50 agents on Base or Ethereum. We email you when a watched agent goes down or comes back, changes ladder step, starts or stops accepting x402 payments, receives a payment, gets a new warning, or touches a contract newly on the Ethereum Foundation's Glamsterdam repricing list. Choose a daily digest, or an email at once when an agent goes down.
- See where an agent owner's wallet has put funds in DeFi: the contracts it used, gross amounts over 90 days, movement by type, and public incident reports we list for those contracts. This is observed on-chain activity, not returns, performance or a safety rating, and it covers only agents whose owner wallet we have scanned.
- Pick a use case and get our verdict on whether an agent fits it.
- Ask the data (beta): ask questions about indexed agents in plain English. Answers use only our data and link to the agent pages they draw on. Up to 20 questions a day and 200 a month.
- Use the full Agent Leaderboard (7-day, 30-day and all-time boards) and the interactive Agent Graph.
- Read the daily dashboard with the Payable and Paid columns, and see the payer and amount on payment events in the live feed.
- Read the latest State of ERC-8004 report (2026-Q3). The opening sections are free to read.
30-day subscription
POST /v1/intel/subscribe · $5.00 USDC · 0.002 ETH
Unlimited access to every per-call intelligence endpoint for 30 days —
profile, search, trending, peers, delta, market, and graph.
After payment confirms, pass your wallet address as the
wallet query parameter on any intel
endpoint to bypass per-query payment.
402 response
{
"sub_id": "sub_96ffad00bfd0",
"preview": {
"sub_id": "sub_96ffad00bfd0",
"duration": "30 days",
"covers": ["trending", "delta", "market", "peers", "agent_profile", "search", "graph"],
"hint": "Pay once, query freely for 30 days — no per-query payments"
},
"payment_options": [ /* USDC + ETH across base, ethereum */ ],
"expires_at": 1748800000 // OFFER window: 15 min. Subscription itself is 30 days after paid_at.
}
After paying with calldata SUB-{sub_id} or via PAYMENT-SIGNATURE (x402 v2) or X-PAYMENT (v1), call any intel endpoint with three signed headers that prove you own the pass wallet:
X-Pass-Wallet— the address that paid for the passX-Pass-Timestamp— unix seconds or milliseconds; must be within 5 minutes of nowX-Pass-Signature— EIP-191personal_signby that wallet overOnchainAgentIntel API pass\nhost: <Host header>\npath: <request path>\ntimestamp: <X-Pass-Timestamp>
Each signature works once, so sign every request (a millisecond timestamp keeps them distinct). A request without a valid signature gets the normal 402 challenge; a bare ?wallet= is not proof and is not enough.
import time, requests
from eth_account import Account
from eth_account.messages import encode_defunct
acct = Account.from_key(PRIVATE_KEY) # the wallet that bought the pass
host, path = "api.onchainagentintel.io", "/v1/intel/trending"
ts = str(int(time.time() * 1000)) # unix ms (seconds also accepted)
msg = f"OnchainAgentIntel API pass\nhost: {host}\npath: {path}\ntimestamp: {ts}"
sig = acct.sign_message(encode_defunct(text=msg)).signature.hex()
r = requests.get(f"https://{host}{path}", headers={
"X-Pass-Wallet": acct.address, "X-Pass-Timestamp": ts, "X-Pass-Signature": sig})
import { Wallet } from "ethers";
const wallet = new Wallet(PRIVATE_KEY); // the wallet that bought the pass
const host = "api.onchainagentintel.io", path = "/v1/intel/trending";
const ts = String(Date.now()); // unix ms (seconds also accepted)
const msg = `OnchainAgentIntel API pass\nhost: ${host}\npath: ${path}\ntimestamp: ${ts}`;
const sig = await wallet.signMessage(msg);
const r = await fetch(`https://${host}${path}`, { headers: {
"X-Pass-Wallet": wallet.address, "X-Pass-Timestamp": ts, "X-Pass-Signature": sig } });
Poll /v1/intel/subscription/{sub_id} to confirm activation.
Subscription status
GET /v1/intel/subscription/{sub_id} · Free · no payment required
Public status check for a subscription. Use the sub_id returned by /v1/intel/subscribe.
200 response
{
"sub_id": "sub_96ffad00bfd0",
"subscriber_addr": "0xyour_lowercased_wallet",
"status": "ACTIVE", // PENDING | ACTIVE | EXPIRED
"created_at": 1748000000,
"paid_at": 1748000123,
"expires_at": 1750592123, // 30 days after paid_at
"amount_eth": 0.002,
"payment_tx": "0x…",
"payment_chain": "base"
}
404 response
{ "detail": "Subscription not found" }
Changes
Rules in force
- The four-step ladder is the only classification.
- Payment verified and Has paying customers lapse after 7 days without an answer from the endpoint and no settled customer payment in the last 30 days (since 2026-11-14; see the changelog below).
- No per-host or per-operator limit on any step. Registrations that share one endpoint count once (changed 2026-11-13; see the changelog below).
- The platform-listed rule applies, as described above.
- The name check applies; the batch-publisher cap is not applied since 2026-11-13 (see the changelog below). Background: Readiness scoring tightened.
Changelog
Live count now includes agents that answer at their listed address, 2026-11-15. On this date the Live count rose by 122 (from 2,137 to 2,259) because the earlier count was too low: we asked only each host’s front page, and these agents answer at the address they list. The check now asks that listed address once when the front page does not answer. An agent counts as Live this way only if the listed address returned a normal reply and we can read a protocol (MCP, OpenAPI or a well-known card) for it; registrations that share one endpoint still count once. 104 agents joined the ladder (71 on Reachable, 33 on Transact-ready); no agent moved down and Payment verified, Has paying customers and the lapse count did not change. Each page that is Live this way says so and shows the date.
What this does not cover: it is one unpaid request a day from our network, at most 150 requests per host per run, one at a time per host and no retries. An address that answers is not proof the service works. Hosts that serve many agents may be checked over several nights. The live feed and watchlist emails carry no per-agent notices for these moves.
Shared payment addresses of linked owners, 2026-11-14. The 2026-11-13 rule (a settled x402 payment to a shared payment address counts once) now also holds when the registrations that name the address have different owner wallets and every one of those wallets is linked to the others on-chain. Two wallets are linked only if both were first funded by the same wallet (not a contract, not a high-volume wallet), or one was first funded by the other and received at least two real transfers from it. Dust, spam tokens, exchanges and bridges never make a link, and each link keeps its transaction on the address page and the agent pages. Four addresses qualify today; the agents behind them keep everything they had, the credited registration is chosen by the same order as before, and 3 agents moved up to Has paying customers (ProductClawd, The Dude’s Store Sales Agent and earner-1); a fourth credited registration was already on that step. No agent moved down.
What this does not cover: a link is something we observed on Base, not a statement about who owns what, and a link we cannot see (an off-chain relation, a transfer on another chain) is not used. An address shared by owners that are not all linked still credits no one. The live feed and watchlist emails carry no per-agent notices for these moves.
Top-step lapse, 2026-11-14. An agent on Payment verified or Has paying customers whose endpoint has not answered our checks for 7 days now loses that step until it answers again. Before, these two steps held on past payments whatever the endpoint did. Corrected the same day: an agent that customers paid in the last 30 days keeps its step even when the address we check does not answer, and our own paid tests do not count as customer payments. After the correction 6 agents lost a step (9 that the first version had lowered were returned); they return the first time a probe gets a normal reply, and none lost its payment evidence. The rule needs probes on at least 4 different days, none answered, and 7 days of history, and it skips probes taken while our own network was degraded. What this does not cover: we check the published endpoint from our network a few times a day, so an agent can be reachable for others and not for us. The live feed and watchlist emails carry no per-agent notices for the first batch.
Lapse check reads the listed URL and known paid routes, 2026-11-14. Our general check asks only for a seller’s front page, so a seller whose front page returns 404 or 405 but whose paid route answers “payment required” looked silent. For agents on Payment verified or Has paying customers whose front page did not answer, we now also make one unpaid daily request to the endpoint URL as listed and to up to 4 paid routes we already know, with the method the route declares (a GET, then one empty POST only after a 404 or 405 when no method is declared). A 2xx, or a 402 with a readable payment request, counts as an answer for this rule, and the page says what we checked and when. No payment is ever sent. The public Live count is unchanged.
Batch-publisher cap removed, 2026-11-13. Scores were capped at 60 for agents whose publisher had registered 100 or more agents on a chain. That cap is gone. Every agent the cap had lowered (about eighteen hundred) now has a higher score and none fell. Ten of them moved up to Transact-ready (a readable payment route, a live endpoint and a score of 75 or more); the rest rose without changing step. A higher score is not a statement that the agent works: step 3 and 4 still need payment evidence, the name check and the one-count-per-endpoint rule still apply, and no agent moved down. The live feed and watchlist emails carry no per-agent notices for these moves.
Ladder rule change, 2026-11-13. The ladder no longer limits agents per host or per operator. Before, the ladder capped Reachable at 5 agents per host and per operator, and Transact-ready at 3 per operator. A step is now a fact about one agent: if its endpoint answers, it has metadata, it speaks an agent protocol and it passes our name checks, it is Reachable, however many sibling agents share its operator or host. Platforms and collections are part of the ERC-8004 economy, and a limit made the ladder understate them.
Numbers today: 2,215 agents are Reachable or higher, from 739 operators; 297 are Transact-ready or higher. The day before the change these were 420 Reachable (302 operators) and 186 Transact-ready. The largest single operator is now 1,111 of the Reachable agents, so every step count is published beside its operator count.
What did not change: steps 2 to 4 still need payment evidence; one count per endpoint; scores are unchanged, and no agent moved down a step. On 2026-11-13 and the day after, the live feed carries one note about the rule change instead of one event per agent, and agent pages say the rule changed under their score history. Read the post: The ladder now counts every agent on its own facts.
Also changed on 2026-11-13: the platform rule. An agent that is on the ladder is now ranked like any other agent, even if it belongs to a platform. It is no longer left out of ranked lists and its page no longer says we rank it with the platform; the page still says which host it is on and how many other agents are there. Agents that are not on the ladder keep the platform rule and its wording. No score, price or ladder count changed.
