.png)
GraphTally: How The Graph Solved Micropayments for the Machine Economy
The World Wide Web is one of the most consequential technologies humans have ever built. Yet the people who designed it overlooked one thing: they built it for humans to use, and that is becoming a problem as automation scales.
The gap is most obvious in payments. Credit card forms, one-click checkout, and QR codes all assume a living person is at the screen, ready to authorize a transaction. Increasingly, that is not who is transacting. A growing machine-to-machine economy is taking shape, driven by autonomous protocols, decentralized applications, and software agents acting on people's behalf. These actors transact very differently from humans. They rarely hold a bank account, and they need to pay on demand only for what they consume, rather than committing to recurring subscriptions for every resource they touch.
Traditional payment rails cannot support high-frequency, fraction-of-a-cent transactions. They are too slow and too expensive, and the fees would often cost more than the value being transferred. Even blockchains, with their promise of low fees, are not efficient enough on their own to settle the smallest payments one by one.
The Graph ran into this problem early, and it had to solve it in production. The result is , the trust-minimized payment system that lets The Graph Network settle high-frequency, sub-cent payments at scale. It is not a thought experiment. It has been the payment layer of a live decentralized network since early 2025.
Why The Graph Needed GraphTally
The Graph is the indexing and query layer of web3, a decentralized protocol for indexing and querying blockchain data. Indexers form the backbone of The Graph Network: they organize blockchain data and serve it to the dapps, analysts, and increasingly the AI systems that query it.
Blockchains produce endless streams of data. Every time a dapp updates an asset price or reads a user's transaction history, it issues a query. Each query is worth only a fraction of a cent, but the most active Indexers serve hundreds of thousands of queries per day, and that number keeps climbing. Settling each one with its own blockchain transaction is infeasible. Even on a low-cost network, a simple transfer can cost several cents, so an Indexer serving 500,000+ queries a day could lose tens of thousands of dollars in fees alone. The Graph Network needed offchain payments with cheap onchain settlement.
GraphTally is that solution. Previously known as the Timeline Aggregation Protocol (or TAP), it is now integrated into the core protocol through Graph Horizon. It rests on a simple idea: keep a running tab offchain, and touch the blockchain only when it is efficient to settle.
How GraphTally Works
In The Graph Network, payments flow in one direction, from a gateway (the Sender) to an Indexer (the Receiver). That one-way structure is what makes the system efficient.
Instead of transferring tokens for every query, a gateway attaches a cryptographically signed Receipt to each request. A Receipt is a verifiable IOU, a signed promise to pay a small fee for the data requested. Because Receipts are created and signed offchain, they can be processed in microseconds with no gas fees.
An Indexer cannot redeem hundreds of thousands of individual Receipts onchain; the cost would defeat the purpose. So GraphTally aggregates them. As an Indexer accumulates Receipts, it batches them into a single Receipt Aggregate Voucher (RAV), which represents the running total owed. When the time comes to settle, the Indexer submits one RAV to the blockchain, compressing a large batch of micropayments into a single transaction.
GraphTally also keeps gateways honest through a threshold the Indexer controls: the maximum amount it is willing to risk in unaggregated Receipts. If a gateway keeps querying past that limit without settling, the Indexer stops serving it. Onchain, smart contracts verify each RAV, hold gateway funds in escrow, and release payment only against valid submissions. Gateway withdrawals require a thawing period, giving Indexers time to claim anything outstanding.
The result meets every requirement the network had: high throughput, since the bottleneck is a fast cryptographic signature; stateless and horizontally scalable senders; trust minimization, since an Indexer can always claim what it is owed onchain without further cooperation from the gateway; and low cost, since the main onchain expense is verifying a single signature.
The Same Ideas, Running in Production Early
GraphTally was built to solve a specific, concrete problem: paying Indexers for the data they serve. But the problem it solves, trust-minimized micropayments between machines at high frequency, is exactly the problem the wider internet is now confronting as software agents come online.
The clearest signal is , an open standard from Coinbase and Cloudflare that revives the dormant HTTP 402 "Payment Required" status code so that any service can charge per request. It is a genuinely important step toward internet-native payments. What is striking, for a broader audience trying to understand where this is heading, is how many of x402's core ideas were already live inside The Graph Network months before x402 was announced. The Graph did not follow this pattern; it shipped it early, because a decentralized network serving real query traffic forced the issue.
Consider the parallels, none of which imply that one project derived from the other:
There is even a place where GraphTally went a step further. High-frequency payment is only half the problem; the harder half is settling all that activity onchain without the fees swallowing the value. GraphTally's answer, aggregating many Receipts into a single RAV so that a large batch of micropayments settles in one transaction, is precisely the optimization a network serving hundreds of thousands of queries a day cannot live without. It is the kind of detail you only solve when you are running the system for real.
The two systems are not rivals; they are complementary layers of the same pipeline, and The Graph runs both. . At the consumer-facing layer, x402 lets agents and applications pay a Subgraph Gateway for per-query access in USDC over HTTP, with no API key, account, or session. At the layer beneath it, GraphTally is the system that lets Indexers accept trust-minimized payments from those gateway operators for the queries they actually serve. A request can flow end to end as machine-native payment: an agent pays a gateway through x402, and the gateway settles with its Indexers through GraphTally. The Graph both helped prove the pattern early and adopts the emerging open standard where it fits, rather than treating the two as a choice.
This is the point worth making for a general audience. Permissionless, machine-native payments are not a future feature The Graph is waiting on; they are infrastructure The Graph already builds, ships, and operates at network scale. The Graph set out to pay its own Indexers, and in doing so it battle-tested a piece of the machine-to-machine economy that the rest of the industry is now standardizing in the open.
About The Graph
The Graph is a suite of blockchain data infrastructure products that extract, process, and deliver scalable blockchain data solutions across 60+ networks. The Graph enables application developers, data analysts, AI agents, and enterprise teams that need structured, real-time access to blockchain data. Products include Subgraphs, Firehose, Substreams, and Amp. As of early 2026, The Graph has served over 1.27 trillion queries to more than 75,000 projects, powered by a network of independent Indexers around the world.
Follow The Graph on , , , and . Join the community on The Graph’s , join technical discussions on The Graph’s .
