The Graph Protocol

The Graph Protocol is a decentralized indexing and querying protocol for blockchain data, enabling applications to efficiently access and retrieve information from networks like Ethereum, IPFS, and other Layer 1 and Layer 2 chains. It functions as a decentralized data marketplace where developers can publish and query open APIs called subgraphs, which define how to index and organize data from specific smart contracts or events. This eliminates the need for applications to run their own centralized indexing servers, creating a more reliable and verifiable data layer for Web3.

The protocol's architecture relies on a network of participants: Indexers (node operators who stake GRT tokens to index data and serve queries), Curators (who signal on valuable subgraphs by depositing GRT), Delegators (who delegate GRT to Indexers), and Consumers (end-users who pay for queries). Queries are processed using GraphQL, a powerful query language that allows developers to request exactly the data they need. This system creates a competitive marketplace for data service, where quality and efficiency are incentivized through the protocol's crypto-economic model.

A subgraph is the core data unit, comprising a subgraph manifest (a YAML file defining the data sources and handlers), a GraphQL schema (defining the shape of the queryable data), and mapping functions (written in AssemblyScript) that translate blockchain events into entities in the GraphQL schema. When a developer deploys a subgraph to the decentralized network, Indexers begin scanning the blockchain for the defined events, processing them through the mappings, and storing the resulting structured data in a queryable database. This process transforms raw, sequential blockchain logs into a rich, relational graph of entities.

The Graph's primary use case is powering decentralized applications (dApps) that require efficient, complex data retrieval, such as DeFi dashboards, NFT galleries, and DAO analytics tools. For example, a DeFi application like Uniswap uses subgraphs to query historical trade data, liquidity pool statistics, and user portfolio balances without needing to process every transaction from the chain's genesis block. This provides a performant user experience comparable to Web2 applications while maintaining the security and verifiability of decentralized infrastructure.

The protocol's native utility token, GRT (The Graph Token), secures the network and coordinates all participants. Indexers stake GRT to provide indexing and query services, earning query fees and indexing rewards. Curators stake GRT to signal which subgraphs are valuable, directing Indexer resources and earning a share of query fees. Delegators can participate by delegating their GRT to Indexers, sharing in their rewards without running infrastructure themselves. This token-incentivized ecosystem ensures the network remains robust, responsive, and aligned with the data needs of developers.

The Graph Protocol operates as a decentralized data layer for Web3, functioning similarly to how APIs serve data in traditional web applications. It allows developers to build and publish open APIs called subgraphs, which define how to ingest, process, and store blockchain data from specific smart contracts. This process transforms raw, sequential blockchain data into a structured, queryable database that applications can efficiently access using GraphQL. By abstracting complex data retrieval logic, The Graph eliminates the need for applications to run their own indexing servers.

The network's core components include Indexers, Curators, and Delegators. Indexers are node operators who stake the native GRT token to provide indexing and query processing services, earning query fees and indexing rewards. Curators signal on high-quality subgraphs by depositing GRT, directing Indexers to prioritize indexing that data. Delegators stake GRT with Indexers to secure the network without running a node themselves, sharing in the rewards. This token-incentivized marketplace ensures data availability and integrity.

A developer's workflow begins by defining a subgraph manifest. This specification outlines the smart contracts to watch, the events to index, and how to map event data into the Graph's data store. Once deployed, the subgraph is indexed by the network. Applications then query this indexed data using precise GraphQL requests, which specify exactly which data fields are needed. This is a significant efficiency gain over directly querying a blockchain node, which would require processing every block to filter for relevant transactions and events.

The protocol's decentralized architecture ensures resilience and censorship resistance. No single entity controls the data pipeline. Query results are cryptographically verified, and a dispute resolution system slashes malicious Indexers' staked GRT. This creates a robust, trust-minimized data backbone for DeFi applications like Uniswap, NFT platforms, and DAO tooling, which rely on real-time, reliable access to on-chain state, historical trends, and aggregated metrics.

A Subgraph is a set of instructions, written in a declarative language called GraphQL, that defines how to index and organize blockchain data from a specific smart contract or protocol. It acts as a data pipeline that listens for events on the blockchain, processes them according to the defined logic, and stores the resulting structured data in a queryable format. Developers deploy subgraphs to The Graph Network, where decentralized Indexers operate them, making the data accessible via performant GraphQL APIs.

The structure of a subgraph is defined by three core components: the subgraph manifest (subgraph.yaml), which maps data sources and their handlers; the GraphQL schema (schema.graphql), which defines the shape of the final queryable data; and the mapping logic (written in AssemblyScript), which contains the code that translates raw blockchain events into the entities in the schema. This separation allows developers to specify what data they want (the schema) and how to derive it from the chain (the mappings).

When a transaction emits an event on-chain, the relevant subgraph's mapping functions are triggered. These handlers—such as handleTransferEvent for an ERC-20 token—extract data from the event, perform any necessary calculations, and create or update corresponding entities in the subgraph's store. For example, a Uniswap subgraph might create Swap, Pool, and Token entities. This process transforms raw, sequential log data into a rich, interconnected graph of entities that can be efficiently queried.

The primary use case for a subgraph is to power the data layer for decentralized applications (dApps). Instead of a dApp frontend making slow, complex direct calls to an Ethereum node, it queries a subgraph's indexed data with a single, efficient GraphQL request. This enables complex queries like "show me all liquidity pools where token X is paired with USDC, sorted by 24-hour volume." Prominent examples include Uniswap's interface, which uses subgraphs to display pool statistics, trade history, and user positions.

In The Graph's decentralized network, subgraphs move through a lifecycle: from development and testing on the hosted service to being published and curated on the mainnet. Curators signal on subgraphs to indicate high-quality data, guiding Indexers to prioritize them. This ecosystem ensures that subgraphs providing valuable data are reliably hosted and maintained in a decentralized manner, forming the backbone of Web3's data infrastructure.