GET /api/address-facts?address=0x… returns what our ledger holds about one address. ?format=file returns the whole file (30,091 rows, 9.7 MB). No key, no sign-up. An address that is missing was never paid by a registered agent with a counted payment; that is not a statement about it.
What is in a row
One row per Base address that a registered agent paid with a counted payment: after the agent was registered, read from the transaction receipt, not a routing hop.
| Field | What it says | Where it comes from |
|---|---|---|
address | The address, lower case. | the payment |
kind | eoa (a plain key), eoa_delegated (a key that delegates to code under EIP-7702), contract, or unclassified. | the code at the address, read from a Base node |
impl_7702 | For a delegated key: the contract it delegates to. | the same read |
label, category | What the code does, when we have a basis that can be cited: swap, bridge, lending, yield vault, work escrow. Empty for most rows. | our label map |
agents_paid | How many different registered agents paid it. | counted payments |
payments, usd | How many counted payments it received from them, and their dollar value. | counted payments |
first_paid, last_paid | Time of the first and of the newest of those payments. | counted payments |
agent_wallet | The address is itself a wallet bound to a registration. | ERC-8004 bindings |
x402_seller | The address is a recipient (payTo) of an x402 service that a public index of x402 services has listed. | x402.recipients.known.v1 |
poison_lookalike | Our poisoning watch counted it as a look-alike planted in an agent's history. | poison.events.24h.v2 |
frozen_by | The stablecoin issuers whose newest freeze-list action on the address is a freeze. | issuer events on Base |
The file of 16 November 2026, 02:20 UTC
Counted from the file itself as the public route served it. The job that writes the file logs three of these totals (addresses, frozen, look-alikes); they agree.
| What | Addresses | Share |
|---|---|---|
| All addresses in the file | 30,091 | 100% |
| Contracts | 17,780 | 59.1% |
| Plain keys | 9,776 | 32.5% |
| Keys that delegate to code (EIP-7702) | 2,535 | 8.4% |
| Wallets bound to a registered agent | 15,311 | 50.9% |
| Recipients of x402 services (from a public index) | 1,022 | 3.4% |
| With a label (34 swap, 15 bridge, 14 yield vault, 7 lending, 1 work escrow) | 71 | 0.2% |
| Paid by one agent only | 12,932 | 43.0% |
| Paid by 2 to 9 agents | 8,520 | 28.3% |
| Paid by 10 to 99 agents | 5,124 | 17.0% |
| Paid by 100 agents or more | 3,515 | 11.7% |
| Planted as a poisoning look-alike | 2 | 0.0% |
| Frozen by a stablecoin issuer | 0 | 0.0% |
Look-alikes. The file lists only addresses agents paid, so a planted look-alike appears here only when a registered agent then sent it a counted payment. 2 of the addresses in this file are (1 counted payment, $50.00; 1 counted payment, $10.00). The file does not say why an agent paid them.
Freezes. No address in this file is on an issuer's freeze list. The field is in every row, so a client that reads it today needs no change on the day one appears.
x402 recipients. 1,022 addresses in this file are recipients of x402 services. The file of 14 November, 08:27 UTC had 831. The rise does not come from agents paying new sellers: the outside index we take these addresses from had not changed for eight weeks and resumed on 13 November, nearly doubling. The step is dated in the register as cp-2026-11-13-x402-recipient-index-resumed. The set holds every recipient that index has listed; it is not a copy of the Bazaar's own list.
Three ways to read it
One address. The answer says found and gives the row. This is the example row in this file: a contract 280 agents paid 1,017 times, $113,020.60 in all.
curl "https://agenticfinancegraph.com/api/address-facts?address=0x498581ff718922c3f8e6a244956af099b2652b2b"
Pages. Most-paid first, up to 5,000 rows a page; next_offset is empty on the last page.
curl "https://agenticfinancegraph.com/api/address-facts?limit=5000&offset=0"
The whole file. Byte for byte as we wrote it, with its SHA-256 in the header X-AFG-SHA256. ?head=1 names the newest file: its time, rows, bytes and hash.
curl -o afg-address-facts.json "https://agenticfinancegraph.com/api/address-facts?format=file"
curl "https://agenticfinancegraph.com/api/address-facts?head=1"
The same facts reach an agent through the MCP tools payee_facts and payer_check (the MCP page), and the Integrate page has the checks with code that was run.
Check that a file is ours
Each time a file is written, the SHA-256 of its exact bytes goes into our signed statement log as one leaf. A head of that log is signed every three hours, and once a day a Base transaction names the head (anchor.v2). So a file you kept can be shown, later and to anyone, to be the one we published at that time.
- Hash. Take the SHA-256 of the file's bytes.
- Log.
/api/statements/proof?sha256=<hash>returns the leaf, its index and the inclusion path under a signed head. The head's key is in the log's own answer. - Chain. After the daily anchor (04:30 UTC) the same answer carries the Base transaction that commits to a head covering the leaf.
This script does the three steps with no dependencies (Node 18 or newer). Save it as check-file.mjs. On the file of 2026-11-16 02:20 UTC it answered: in the log, leaf 366 under the head of size 368, signature valid. On a copy with one byte changed it answered: no leaf.
// node check-file.mjs <file> Node 18 or newer, no dependencies.
// Is this file, byte for byte, one that Agentic Finance Graph published, and when? The file's SHA-256 must be a leaf of
// the signed statement log, under a head signed with the key the log publishes.
import { createHash, createPublicKey, verify } from "node:crypto";
import { readFileSync } from "node:fs";
const SITE = "https://agenticfinancegraph.com";
const sha = (...b) => createHash("sha256").update(Buffer.concat(b)).digest();
const hex = (s) => Buffer.from(s.replace(/^0x/, ""), "hex");
const get = async (p) => (await fetch(SITE + p)).json();
async function check(file) {
const hash = sha(readFileSync(file)).toString("hex");
const proof = await get("/api/statements/proof?sha256=" + hash);
if (!proof.ok) { console.log("no leaf for " + hash + ": not a file we published, or not byte for byte"); return 1; }
const L = proof.log, head = L.signed_head;
if (!L.leaf.startsWith("publication/1|") || L.leaf.split("|")[2] !== hash) { console.log("FAILED: the leaf does not carry this hash"); return 1; }
console.log("leaf " + L.leaf);
if (!head) { console.log("written to the log; the next signed head (every three hours) will cover it"); return 0; }
// RFC 6962 inclusion proof: from the leaf up to the head's root
let r = sha(Buffer.from([0]), Buffer.from(L.leaf, "utf8")), fn = L.leaf_index, sn = head.tree_size - 1;
for (const p of L.audit_path.map(hex)) {
if (fn % 2 === 1 || fn === sn) { r = sha(Buffer.from([1]), p, r); while (fn % 2 === 0 && fn !== 0) { fn >>= 1; sn >>= 1; } }
else r = sha(Buffer.from([1]), r, p);
fn >>= 1; sn >>= 1;
}
const inLog = sn === 0 && "0x" + r.toString("hex") === head.root_hash;
// the head's signature, with the key the log publishes
const log = await get("/api/statements/log");
const key = createPublicKey({ key: Buffer.concat([Buffer.from("302a300506032b6570032100", "hex"), hex(log.key.public_key_hex)]), format: "der", type: "spki" });
const signed = verify(null, Buffer.from("afg-statement-log:v1:" + head.tree_size + ":" + head.root_hash + ":" + head.timestamp_ms), key, Buffer.from(head.signature, "base64"));
console.log("in log " + (inLog ? "yes" : "NO") + ", leaf " + L.leaf_index + " under the head of size " + head.tree_size + " signed " + new Date(head.timestamp_ms).toISOString());
console.log("head signature " + (signed ? "valid" : "INVALID") + ", key " + log.key.key_id);
console.log("Base " + (L.base_anchor ? "anchored in block " + L.base_anchor.block + ", " + L.base_anchor.explorer : "the daily anchor (04:30 UTC) will commit to a head that covers it"));
return inLog && signed ? 0 : 1;
}
process.exitCode = await check(process.argv[2]);
node check-file.mjs afg-address-facts.json
The same route proves any other file whose hash we wrote into the log: an edition, an Agent Books statement, a Gate receipt, the pinned list of our MCP tools. Files written before 14 November 2026, 08:27 UTC have no leaf: the feed began on 8 November and its files were not logged until then.
What the feed does not say
- No score and no verdict. Nothing here says an address is good, bad, safe or risky. A flag is a fact with a source: a freeze is an issuer's action on chain, a look-alike is a pattern our rule counted.
- Not who owns an address. A label names what the code does. It never names a person.
- Absence is not clearance. The file holds addresses that registered agents paid on Base with counted payments. Everything else is simply not in it: other chains, payments before registration, routing hops, addresses nobody in our ledger paid.
- Labels are few. 71 of 30,091 rows carry one. We label only where the basis can be cited.
- It can be late. The file is up to six hours old by design, and a payment is counted only after its receipt is read. Read
as_of. - We never block. What a wallet, a seller or an agent does with a fact is its own decision.
Who it is for
- Wallet-security products and payment checks that screen a payee before a payment: is this a plain key or code, has any agent paid it before, how many, was it planted as a look-alike, is it frozen.
- Sellers and platforms that agents pay: the same row answers “who is paying me” for an address, and the free payer check adds what a registration bound to it looks like.
- Researchers who need the set of addresses agent money actually reaches, with a file they can cite by hash.
Licence: CC BY 4.0. Name the source as “Agentic Finance Graph — https://agenticfinancegraph.com” and keep the file's time beside any figure. The definition, with every limit, is address.facts.v1; corrections are dated in the register.
FAQ
Is an address that is not in the file safe to pay?
No. An address is missing when no registered agent has paid it with a counted payment on Base. That says nothing else about it. The file lists facts about addresses agents did pay; it has no score and gives no verdict on any address.
How do I know a file is yours and was not changed?
Take the SHA-256 of the file's bytes and ask /api/statements/proof?sha256=…. If we published those bytes, the answer carries the leaf, its place in our signed log and, after the daily anchor, the Base transaction that commits to it. A file changed by one byte has another hash and no leaf.
Can I use the file in a commercial product?
Yes. The licence is CC BY 4.0: use it, change it, sell what you build on it, and name the source as “Agentic Finance Graph — https://agenticfinancegraph.com”. Keep the file's time (as_of) next to any figure you show.
Does the file say who owns an address?
No. A label names what the code at an address does (a swap router, a bridge, a lending pool), each with a basis that can be cited. It never names a person, and it is not a statement about a company.
How fresh is it?
A new file is written four times a day, shortly after 02:15, 08:15, 14:15 and 20:15 UTC. Each file carries its own time in as_of. Between two files the route keeps serving the last one.