The Graph Protocol — The Internet of Blockchains' Missing Search Engine

Imagine Google didn't exist, and every time you wanted to find something on the internet, you had to read every single web page from the beginning. That's roughly the situation Web3 developers faced before The Graph came along.

Why querying blockchains is hard

Blockchains like Ethereum are, at their core, append-only ledgers. Every transaction, every smart contract interaction, every token transfer — it all gets recorded into sequential blocks. The data is transparent and immutable, which is wonderful for trustlessness. But it creates a painful problem for developers building applications on top of it.

Say you're building a decentralised exchange and you want to show a user their complete trading history. On a traditional web app, you'd hit a database with a SQL query and be done in milliseconds. On Ethereum, you'd need to scan potentially millions of blocks, filter for transactions relevant to that user's address, decode raw hex data, and piece together a coherent picture — all before you can render a single screen.

⚠️

The raw RPC problem

Ethereum's standard node API (called JSON-RPC) is designed for writing to the chain, not reading from it efficiently. Fetching historical data through raw RPC calls is slow, expensive, and often unreliable at scale.

This is the gap The Graph Protocol was built to fill. It acts as a dedicated indexing layer that sits between raw blockchain data and the applications that need to query it — much like a search engine indexes the web so you don't have to crawl it yourself.

60B+ Queries per month

40+ Supported chains

1000s Active subgraphs

Infographic The Graph Protocol — complete visual reference

The Graph Protocol infographic showing network participants, subgraph anatomy, data flow, supported networks, and the subgraph lifecycle

The complete picture: how The Graph Protocol indexes blockchain data and serves it to dApps via GraphQL.

So what exactly is The Graph?

The Graph is an open-source, decentralised indexing protocol. In plain English: it reads blockchain data, organises it into a structured format, and makes it queryable through a standard API called GraphQL — a query language already familiar to millions of web developers.

Instead of every application team building their own custom blockchain crawler (and doing it badly, slowly, and expensively), The Graph provides shared infrastructure that anyone can use. Protocols like Uniswap, Aave, Compound, and ENS all rely on it to power their user interfaces.

"The Graph is to blockchain data what Google is to the web — an indexing layer that transforms raw, hard-to-search information into something instantly useful."

Web3 Infrastructure Series

The building block: subgraphs

The core unit of The Graph is something called a subgraph. A subgraph is an open API that a developer deploys to tell The Graph exactly what blockchain data to watch and how to organise it.

Think of it like setting up a very focused, automated filing system. You tell it: "Watch this smart contract. Every time this specific event fires, extract these fields, relate them to these other entities, and store them in this shape." From that point on, the data is indexed continuously and available for anyone to query.

Each subgraph is made up of three files:

File 1 · YAML

The Manifest

subgraph.yaml — declares which blockchain, which smart contracts to watch, and which events to react to.

File 2 · GraphQL

The Schema

schema.graphql — defines your data model: what entities exist, what fields they have, and how they relate.

File 3 · AssemblyScript

The Mappings

Handler functions that transform raw blockchain events into the structured entities defined in your schema.

The Result

A GraphQL API

Once deployed, your subgraph is a live, queryable API endpoint returning millisecond responses instead of hour-long scans.

Example GraphQL query to a subgraph

# Fetch the 5 most-traded tokens on a DEX
query TopTokens {
  tokens(first: 5, orderBy: totalVolumeUSD, orderDirection: desc) {
    id
    symbol
    name
    totalVolumeUSD
    txCount
  }
}

💡

Already know REST APIs?

GraphQL works similarly but lets you ask for exactly the fields you need in one request. No over-fetching, no under-fetching — just the data you asked for.

How the data flows, step by step

A smart contract fires an event

A user swaps tokens on a DEX. The smart contract emits a Swap event containing price, amounts, and addresses.

The subgraph's mapping handler fires

The AssemblyScript handler you wrote intercepts that event and transforms the raw data into a Swap entity matching your schema.

The Graph Node stores it

An Indexer's Graph Node writes the structured entity to a Postgres database, keeping a fully indexed, up-to-date snapshot of all relevant chain state.

Your dApp queries the GraphQL API

Your frontend fires a GraphQL query. The response comes back in milliseconds — no block scanning, no RPC bottlenecks.

Who keeps it all running?

The Graph's decentralised network is sustained by three types of participants, all economically incentivised using the protocol's native token, GRT.

Role 1

Indexers

Run Graph Nodes that index subgraphs and serve queries. They stake GRT and earn query fees and indexing rewards in return.

Role 2

Curators

Signal which subgraphs are high quality by depositing GRT on them. Their signal directs Indexers toward the most valuable subgraphs.

Role 3

Delegators

Don't want to run a node? Stake your GRT by delegating it to an Indexer and earn a share of their rewards passively.

The Token

GRT

The economic glue of the network. Used for staking, curation signals, query payment, and governance participation.

ℹ️

Hosted Service vs. Decentralised Network

The Graph offers both a centrally hosted service (simpler, good for development) and a fully decentralised network (production-grade, censorship-resistant). Most serious protocols migrate to the decentralised network.

Deploying your first subgraph

Getting started is more approachable than it sounds. The Graph CLI handles most of the scaffolding. Here's the rough workflow:

Terminal — scaffold and deploy a subgraph

# Install the Graph CLI
npm install -g @graphprotocol/graph-cli

# Scaffold a new subgraph from a contract ABI
graph init --studio my-subgraph

# Compile and check the subgraph
graph codegen && graph build

# Authenticate and deploy to Subgraph Studio
graph auth --studio <your-deploy-key>
graph deploy --studio my-subgraph

After deployment, Indexers on the network begin syncing historical data from your contract's genesis block. Once synced, queries are live. Curators can signal on your subgraph to attract more Indexers and ensure high availability.

Supported chains already include Ethereum mainnet and all major testnets, Polygon, Arbitrum, Optimism, Base, Avalanche, BNB Chain, and more than 40 others — with new networks added regularly through governance.

The essential takeaway

Querying raw blockchains is slow and expensive — The Graph solves this with a dedicated indexing layer.
Subgraphs are open APIs you define: which contract to watch, what data to extract, and how to structure it.
Queries use GraphQL — familiar, flexible, and fast — returning structured data in milliseconds.
The network is sustained by Indexers, Curators, and Delegators, all incentivised with GRT.
Major protocols — Uniswap, Aave, ENS, Compound — already depend on The Graph in production.
Getting started takes minutes with the Graph CLI and Subgraph Studio.