---
title: Using Substreams.dev to Find Substreams Packages
sidebarTitle: Using Substreams.dev
---

Use [Substreams.dev](https://substreams.dev/) and take full advantage of its core features to discover ready-to-use Substreams packages for the data you want.

## Overview

This guide explains how to use [Substreams.dev](https://substreams.dev/) (the Substreams Registry) to quickly discover, inspect, and consume Substreams packages. Where [Graph Explorer](/subgraphs/existing-subgraphs/explorer/) helps you find published Subgraphs, Substreams.dev is the storefront for the Substreams ecosystem: it lets you browse curated data collections, inspect individual packages and their modules, explore what's available per chain, and learn from real-world projects.

> When you visit [Graph Explorer](https://thegraph.com/explorer), you can also access the link to [explore Substreams](https://substreams.dev/).

The goal of this page is to help **data consumers** answer a single question: _"Is there already a Substreams package that produces the data I need, and how do I start streaming it?"_ If you're ready to build your own package instead, see the [Substreams Quick Start](/substreams/quick-start/).

## Prerequisites

- Basic familiarity with [Substreams](/substreams/overview/) and the idea that a package (`.spkg`) is a precompiled binary describing the data to extract from a chain.
- The [Substreams CLI](https://docs.substreams.dev/reference-material/substreams-cli/installing-the-cli) installed if you plan to inspect or run packages locally (`substreams gui`, `substreams run`, `substreams info`).
- An API key to stream on-chain data. Substreams is permissionless — you can [obtain a key here](https://thegraph.market/) without providing personal information.
- A GitHub account if you plan to log in, create an authentication token, or [publish your own package](/substreams/publishing/).

## Navigating Substreams.dev

Substreams.dev is organized into four primary areas, each answering a different discovery question. The sections below walk through each one in the order you'd typically use them.

| Area         | Discovery question it answers                                  |
| ------------ | -------------------------------------------------------------- |
| **Datasets** | "What kind of data am I looking for?" (browse by use case)     |
| **Packages** | "Which specific package produces it, and what does it output?" |
| **Chains**   | "What's available on the network I care about?"                |
| **Projects** | "How have others put this data to use?"                        |

### Datasets

> Datasets are curated collections of Substreams packages, grouped so you can start from the _kind_ of data you want rather than a package name. (Referred to here by their current site label, "Datasets.")

The **[Datasets](https://substreams.dev/)** area is the best starting point when you know the type of on-chain activity you want but not the exact package. Instead of searching by keyword, you pick a data domain and move into a vetted set of packages that produce it.

Datasets are organized by use case, including categories such as:

- DEX / AMMs (e.g., swap feeds)
- Lending
- Liquid Staking
- Protocol Staking
- Perps / Derivatives (e.g., position monitoring)
- Prediction Markets
- Governance
- Oracles
- Bridges
- Stablecoins
- NFTs
- Core Data

Each dataset card typically surfaces:

- The category name and whether it is **Featured**
- The number of curated packages available in that category
- The blockchains covered (such as Ethereum, Solana, Polygon, Arbitrum, Optimism, and Base)
- Typical outputs or use cases (for example, "swap feeds" or "position monitoring")
- A status indicator (such as "In progress") when a collection is still being assembled

**How to use it:** Select a data domain, review the curated package recommendations inside it, then choose how you want to consume the data — package-level CLI, JavaScript, local execution, or a deployment path through the [Substreams x The Graph Market](https://thegraph.market/) workflow. This is the fastest route from "I need DEX swaps" to a package that produces them.

### Packages

The **[Packages](https://substreams.dev/)** area is the core of the registry. A Substreams package is a precompiled `.spkg` binary that defines exactly what data is extracted and transformed from a chain — conceptually similar to the mapping logic in a traditional Subgraph.

Package listings can be sorted and browsed by:

- **Last uploaded** — the most recently published packages
- **Featured** — highlighted, recommended packages
- **Most downloaded** — the most widely used packages
- **Most used** and **Alphabetical** — additional ordering options when searching

Each package entry generally shows its name, creator, target network, version, published date, and download count. This metadata helps you quickly gauge maturity and adoption before committing to a package.

Click into any package to reach its dedicated page, where you can:

- View package metadata — name, version, documentation, and target network
- Inspect the **module graph (DAG)**: every module, its kind (`map`, `store`, or `blockIndex`), output types, and update policies
- See how modules depend on one another (`dependsOn` / `dependedBy`) and the input chain for each module (source blocks, other maps, stores in get/deltas mode, and params)
- Review the **protobuf output types** and proto files the package produces, so you know the exact shape of the data
- Copy ready-to-run commands to stream or deploy the package

**Inspecting a package from the CLI.** Once you have a package's `.spkg` URL, you can inspect and run it directly without downloading anything first:

```bash
# See a package's modules, output types, and metadata
substreams info https://spkg.io/creator/package-v1.0.0.spkg

# Explore results interactively in a terminal UI
substreams gui https://spkg.io/creator/package-v1.0.0.spkg <module_name>

# Stream output from a specific module
substreams run -e mainnet.eth.streamingfast.io:443 https://spkg.io/creator/package-v1.0.0.spkg <module_name> -t +1000
```

> Tip: You can also search the substreams.dev registry, inspect packages, read their module DAGs, and generate sink commands with your AI coding assistant using [Substreams Skills](/substreams/tooling/skills/), which give agents deep Substreams expertise for discovering and analyzing existing packages.

### Chains

The **[Chains](https://substreams.dev/)** area lets you discover data by starting from a network rather than a use case. It's the right entry point when your question is "what Substreams data can I get on _this_ chain?"

The Chains view organizes blockchain families and surfaces, for each network:

- The available **endpoints** used to stream data (for example, "3 networks / 12 endpoints" for Ethereum)
- The **block model** for the chain (how blocks and their contents are represented)
- The packages available for that network

Networks span several ecosystems, including Ethereum, Solana, BNB Chain, Arbitrum, Polygon, and Near, with additional chains supported across the broader Substreams ecosystem. Selecting a chain filters discovery down to what's available there, so you can move straight from a network choice to a compatible package and its streaming endpoint.

### Projects

The **[Projects](https://substreams.dev/)** area showcases real-world implementations — practical examples of how teams have used Substreams packages to power applications, pipelines, and data products.

Use Projects to:

- See end-to-end examples of packages in production, from discovery through to a live data sink
- Understand common patterns for wiring packages into applications and databases
- Get ideas for how to combine packages in a more composable way

Projects are especially useful once you've found candidate packages in Datasets or Packages and want to see how similar data has been consumed and sinked in practice.

## Consuming Package Data

After you've found a package that fits your needs, you choose how to consume the data. Substreams supports multiple sinks:

- **[Subgraph](/sps/introduction/)** — configure an API to meet your data needs and host it on The Graph Network.
- **[SQL Database](https://docs.substreams.dev/how-to-guides/sinks/sql-sink)** — send the data to a Postgres or Clickhouse database.
- **[Direct Streaming](https://docs.substreams.dev/how-to-guides/sinks/stream)** — stream data directly into your application.
- **[PubSub](https://docs.substreams.dev/how-to-guides/sinks/pubsub)** — publish data to a PubSub topic.

Many package pages will help you identify the right sink. If a package has an embedded sink configuration, it can produce ready-to-run `install`, `setup`, and `run` commands with the correct network endpoint; if not, you can still check whether its modules output sink-compatible types (such as `DatabaseChanges`) and wire up a sink yourself.

## Publishing Your Own Package

If you can't find a package that produces the data you need, you can build and publish one. Substreams packages are written in Rust, and once compiled to an `.spkg` you can share them with the community through the registry. See [Publishing a Substreams Package](/substreams/publishing/) for the full flow, and the [Substreams Quick Start](/substreams/quick-start/) to start building.

## Additional Resources

- [Substreams Overview](/substreams/overview/) — what Substreams is and how it works.
- [Substreams Quick Start](/substreams/quick-start/) — use ready-made packages or develop your own.
- [Substreams Registry](https://substreams.dev/) — browse the full, growing collection of packages.
- [StreamingFast Substreams Docs](https://docs.substreams.dev/) — reference material, tutorials, and how-to guides maintained by the core development team.
- [The Graph Market](https://thegraph.market/) — obtain a key and provision packages for production.
