Indexing Data on Tempo

Tempo is an EVM-compatible Layer 1 built by Stripe and Paradigm for stablecoin payments, designed for high-throughput, low-cost enterprise payment flows. 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.

Tempo is supported by The Graph in two ways:

• You can develop and publish Subgraphs in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
• You can also consume Substreams — a real-time streaming engine for high-throughput use cases via Pinax Network⁠.

Indexing Tempo with Subgraphs

Getting smart contract data is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. The Graph removes that work, giving you an open API, called a Subgraph, that you query with GraphQL.

Tempo is EVM-compatible, so the Subgraph workflow is the same as on most EVM chains. You develop and test your Subgraph in Subgraph Studio, then query it through the development endpoint.

Quick Start: Build Your Own Subgraph

Building a Subgraph for Tempo takes four steps:

1. Create your Subgraph in Subgraph Studio.
2. Initialize a Subgraph project from your Tempo contract.
3. Deploy it to Subgraph Studio and test it in the playground.
4. Query it over GraphQL with the development endpoint.

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 (MetaMask, Coinbase Wallet, WalletConnect, or Safe). Create a Subgraph, then copy its slug and your deploy key from the Subgraph details page — you use both from the CLI. For a full walkthrough, see Using Subgraph Studio.

Step 2: Initialize your Subgraph project

Install the Graph CLI with the package manager you prefer:

1# npm2npm install -g @graphprotocol/graph-cli@latest34# or yarn5yarn global add @graphprotocol/graph-cli

Initialize from your Tempo contract:

1graph init

The CLI walks you through a set of prompts:

• Protocol: choose ethereum. Tempo is EVM-compatible.
• Subgraph slug: use the slug of the Subgraph you created in Subgraph Studio, for example my-tempo-subgraph.
• Directory: where the project is scaffolded.
• Ethereum network: select tempo from the list of supported networks.
• Contract address: the address of the contract you want to index. Find it on explore.tempo.xyz.
• ABI: if the CLI cannot fetch the ABI, export it from your build artifacts or the the Tempo explorer 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.

Point the manifest at Tempo:

1dataSources:2- kind: ethereum3  name: MyContract4  network: tempo5  source:6    address: '0xYourTempoContractAddress'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 with the deploy key from your Subgraph details page:

1graph auth <DEPLOY_KEY>

Then deploy your Subgraph to Subgraph Studio (the CLI asks for a version label such as 0.0.1):

1graph deploy <SUBGRAPH_SLUG>

Deploying pushes your Subgraph to Subgraph Studio, where you can test it in the playground and check indexing logs. It does not publish it to the decentralized network — see Using Subgraph Studio for details.

Step 4: Query your Subgraph

Once your Subgraph is syncing in Studio, test your queries against the development query URL shown on the Subgraph details page.

1. Create an API key from the API Keys dashboard at thegraph.com/studio.
2. Send GraphQL queries to the development query URL with your API key. The development endpoint is rate-limited (currently 3,000 queries per day).

You can publish your Subgraph to The Graph Network at any time, but Indexers are not guaranteed to serve Tempo Subgraphs yet, so the Subgraph Studio development endpoint is the reliable way to query today.

See Querying The Graph for the full query API.

Indexing Tempo with Substreams

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. Tempo is served with the base EVM block model, so Substreams modules have access to block, transaction, and event (log) 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 covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Tempo; 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](https://app.pinax.network/).
2. Scaffold a project with substreams init and choose the EVM path, pointing it at your Tempo 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.