Agentic Finance Graph

Home/Security layer/Address facts

Data feed · Free · CC BY 4.0 · Every six hours

Every address AI agents pay on Base, with what we know of it

One file, rebuilt four times a day: 30,091 addresses on 16 November, each with its code type, how many registered agents paid it and how much, and whether it was planted as a look-alike or frozen by a stablecoin issuer. Facts, no score. The hash of every file is in our signed log, so anyone can show what we published and when.

Agentic Finance Graph · Published · figures from the file of · definition address.facts.v1

Direct answer 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.

FieldWhat it saysWhere it comes from
addressThe address, lower case.the payment
kindeoa (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_7702For a delegated key: the contract it delegates to.the same read
label, categoryWhat 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_paidHow many different registered agents paid it.counted payments
payments, usdHow many counted payments it received from them, and their dollar value.counted payments
first_paid, last_paidTime of the first and of the newest of those payments.counted payments
agent_walletThe address is itself a wallet bound to a registration.ERC-8004 bindings
x402_sellerThe address is a recipient (payTo) of an x402 service that a public index of x402 services has listed.x402.recipients.known.v1
poison_lookalikeOur poisoning watch counted it as a look-alike planted in an agent's history.poison.events.24h.v2
frozen_byThe 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.

WhatAddressesShare
All addresses in the file30,091100%
Contracts17,78059.1%
Plain keys9,77632.5%
Keys that delegate to code (EIP-7702)2,5358.4%
Wallets bound to a registered agent15,31150.9%
Recipients of x402 services (from a public index)1,0223.4%
With a label (34 swap, 15 bridge, 14 yield vault, 7 lending, 1 work escrow)710.2%
Paid by one agent only12,93243.0%
Paid by 2 to 9 agents8,52028.3%
Paid by 10 to 99 agents5,12417.0%
Paid by 100 agents or more3,51511.7%
Planted as a poisoning look-alike20.0%
Frozen by a stablecoin issuer00.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.

  1. Hash. Take the SHA-256 of the file's bytes.
  2. 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.
  3. 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.