Indexing Data on OP Sepolia Testnet

OP Sepolia Testnet is the public test network for Optimism (OP Mainnet), the OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.

OP Sepolia Testnet is supported by The Graph in two ways:

• Subgraphs: The blockchain indexing standard perfect for small to medium-sized projects that need hosted APIs. Data consumers manage their service in Subgraph Studio while Indexers on The Graph Network sync and serve queries.
• Substreams: A real-time streaming engine for transaction-heavy projects, high-throughput chains, and institutions that need custom data infrastructure. Data consumers can manage their service and get indexing via Pinax Network⁠.

Getting smart contract data is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. Subgraphs remove that work, giving you an open API that you query with GraphQL.

OP Sepolia Testnet is EVM-compatible, so the Subgraph workflow is the same as on most EVM chains. You point a Subgraph at your OP Sepolia Testnet contract, define the entities you want, deploy and publish it through Subgraph Studio, and Indexers on The Graph Network keep those entities current and queryable.

Search Graph Explorer for Existing Subgraphs

Before you build, check whether the data you need is already live. Graph Explorer lists every Subgraph published to The Graph Network:

• Filter by network: on the Subgraphs page, filter by OP Sepolia Testnet to see the Subgraphs indexing it, then sort by most queried, most curated, or recently updated.
• Search by contract: enter a contract address in the search bar to find the Subgraphs that index it.
• Try it first: open any Subgraph to test queries in its playground and copy its query URL.

If an existing Subgraph covers your use case, skip to querying it with your API key. For a full tour, see Using Graph Explorer.

Quick Start: Build Your Own Subgraph

Building a Subgraph for OP Sepolia Testnet takes five steps:

1. Create your Subgraph in Subgraph Studio.
2. Build a Subgraph project from your smart contract.
3. Deploy it to Subgraph Studio.
4. Publish it to The Graph Network from Subgraph Studio.
5. Query Subgraph with your API key.

See the Subgraph pricing page for current query rates and free-tier limits.

Step 1: Create your Subgraph in Subgraph Studio

Open Subgraph Studio and connect your wallet. Create a Subgraph, copy its slug and your deploy key from the Subgraph details page to use in the CLI. For a full walkthrough, see Using Subgraph Studio.

Step 2: Initialize and build your Subgraph project

Install the Graph CLI, verify the install, and initialize a project from your OP Sepolia Testnet contract:

1# Install the Graph CLI (or with yarn: yarn global add @graphprotocol/graph-cli)2npm install -g @graphprotocol/graph-cli@latest34# Verify the install5graph --version67# Initialize from your OP Sepolia Testnet contract8graph init

The CLI walks you through a set of prompts:

• Protocol: choose ethereum. OP Sepolia Testnet is EVM-compatible.
• Subgraph slug: use the slug of the Subgraph you created in Subgraph Studio, for example my-optimism-sepolia-subgraph.
• Directory: where the project is scaffolded.
• Ethereum network: select optimism-sepolia from the list of supported networks.
• Contract address: the address of the contract you want to index. Find it on optimism-sepolia.blockscout.com.
• ABI: if the CLI cannot fetch the ABI, export it from your build artifacts or the Blockscout contract page. Supply it as a JSON file.
• Start block: the block your contract was deployed at. Set this so indexing does not scan from genesis. The explorer shows the deployment block.
• Contract name: the name of your contract.
• Index contract events as entities: set this to true. The CLI then scaffolds entities and mappings for every emitted event.

To customize your Subgraph, you work with three files:

• Manifest: subgraph.yaml defines which data sources your Subgraph indexes.
• Schema: schema.graphql defines the entities you want to query.
• Mappings: src/mapping.ts uses AssemblyScript that translates on-chain events into your entities.

Point the manifest at OP Sepolia Testnet:

1dataSources:2- kind: ethereum3  name: MyContract4  network: optimism-sepolia5  source:6    address: '0xYourOptimismSepoliaContractAddress'7    abi: MyContract8    startBlock: 123456 # your contract's deployment block

For a full walkthrough of schema and mapping authoring, see Creating a Subgraph. Then generate types and build:

1graph codegen && graph build

Step 3: Deploy to Subgraph Studio

Authenticate the CLI and deploy your Subgraph to Subgraph Studio:

1# Authenticate with the deploy key from your Subgraph details page2graph auth <DEPLOY_KEY>34# Deploy to Subgraph Studio (the CLI asks for a version label such as 0.0.1)5graph deploy <SUBGRAPH_SLUG>

Deploying pushes your Subgraph to Subgraph Studio, where you can test it in the playground, query the development endpoint, and check indexing logs. It does not publish it to the decentralized network yet.

Optional: Verify locally with Graph Node Dev Mode

Run your Subgraph on your machine with Graph Node Dev Mode (GND), pointed at an RPC endpoint for OP Sepolia Testnet. From your Subgraph project directory:

1# Install gnd with the Graph CLI2graph node install34# Build, deploy, and index your Subgraph locally, redeploying on changes5gnd --ethereum-rpc optimism-sepolia:https://opsepolia.rpc.service.pinax.network --watch

Query your Subgraph at http://localhost:8000/subgraphs/name/subgraph-0/ until your entities look right, then publish. On Windows, gnd also needs a --postgres-url. See Graph Node Dev Mode for setup.

Step 4: Publish & Curate on The Graph Network

Publishing a Subgraph is an on-chain action that:

• makes it available for Curators to add signal that attracts Indexers,
• makes your Subgraph available for decentralized Indexers to index,
• and makes it publicly searchable and queryable in Graph Explorer.

To publish, open your Subgraph in the Subgraph Studio dashboard and click Publish. Connect your wallet, add metadata (name, description, image), and confirm the transaction. Publishing happens on Arbitrum One, where The Graph’s protocol contracts live, not on OP Sepolia Testnet. For details, see Publishing a Subgraph, which also covers publishing from the CLI with graph publish.

Step 5: Query your Subgraph

After you publish, open your Subgraph in Graph Explorer and copy its query URL from the Query button.

1. Create an API key from the API Keys dashboard at thegraph.com/studio. This dashboard handles API keys and billing for The Graph Network.
2. Send GraphQL queries to the query URL with your API key.

See the Subgraph pricing page for query rates, and Querying The Graph for the full query API.

Substreams is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via 10+ supported sinks. OP Sepolia Testnet is served with the extended EVM block model, so Substreams modules have access to full transaction, call, and event data. Modules are written in Rust and composed into reusable packages.

Find an Existing Module on Substreams.dev

Before writing any code, check the Substreams Registry⁠ for a package that already does what you need. The registry hosts community- and team-built modules — DEX trades, token transfers, contract events, and more — that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on OP Sepolia Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.

Develop Your Own Substreams Module

If no existing module fits, you can build one. The Substreams Quick Start is the full walkthrough. In short:

1. Install the Substreams CLI and get an API key from Pinax Network.
2. Scaffold a project with substreams init and choose the EVM path, pointing it at your OP Sepolia Testnet contract.
3. Write your extraction and transformation logic in Rust, then run substreams build.
4. Stream the output with substreams gui (or substreams run) to iterate, then publish your package to the Substreams Registry⁠ to reuse or share it.