From 80819ab36aabf29eac8d0e66a9354670bf3e403f Mon Sep 17 00:00:00 2001 From: Daniel Keyes <37008057+chillsauce@users.noreply.github.com> Date: Sun, 4 Oct 2026 21:10:42 -0400 Subject: [PATCH 1/3] docs(indexers): add Pinax Pinax serves Celo mainnet over Firehose, Substreams and archive JSON-RPC, and Celo Sepolia over RPC, but was not listed under Indexers. Adds the provider page, registers it in docs.json, and adds the bullet to the indexers overview. Co-Authored-By: Claude Opus 5 (1M context) --- docs.json | 2 +- tooling/indexers/overview.mdx | 4 +++ tooling/indexers/pinax.mdx | 46 +++++++++++++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 tooling/indexers/pinax.mdx diff --git a/docs.json b/docs.json index 9926076ab6..a8549b9a82 100644 --- a/docs.json +++ b/docs.json @@ -309,7 +309,7 @@ "tooling/indexers/envio", "tooling/indexers/goldrush", "tooling/indexers/indexing-co", - "tooling/indexers/codex" + "tooling/indexers/codex", "tooling/indexers/pinax" ] }, { diff --git a/tooling/indexers/overview.mdx b/tooling/indexers/overview.mdx index 2a964ac4ee..f0b8ff4872 100644 --- a/tooling/indexers/overview.mdx +++ b/tooling/indexers/overview.mdx @@ -23,6 +23,10 @@ Getting historical data on a smart contract can be frustrating when you’re bui - SubQuery is a fast, flexible, and reliable data indexing solution for blockchain developers. It allows you to index and query blockchain data with ease, providing a powerful tool for building decentralized applications. - [Documentation](https://academy.subquery.network/) - The SubQuery Academy provides comprehensive documentation and tutorials to help you get started with SubQuery. It covers everything from basic concepts to advanced usage, ensuring you have all the information you need to build with SubQuery. +- [Pinax](https://pinax.network/) + - Pinax streams full Celo blocks over Firehose and runs Substreams modules on its own infrastructure, for teams building custom indexing pipelines rather than subgraphs. It also serves archive JSON-RPC for Celo mainnet and Celo Sepolia. + - [Indexing Celo data with Pinax](/tooling/indexers/pinax) + - Endpoints for Firehose, Substreams, and RPC, with the authentication each one uses. - [Codex](https://www.codex.io/) - Codex is a blockchain data API that provides real-time and historical DeFi data across 80+ networks via GraphQL, including Celo. With access to over 70 million tokens and 700 million wallets, Codex delivers sub-second data for building token explorers, trading bots, portfolio trackers, and DeFi dashboards. - [Bitquery](https://bitquery.io/blockchains/celo-blockchain-api) diff --git a/tooling/indexers/pinax.mdx b/tooling/indexers/pinax.mdx new file mode 100644 index 0000000000..166d84feb8 --- /dev/null +++ b/tooling/indexers/pinax.mdx @@ -0,0 +1,46 @@ +--- +title: Pinax +description: Stream Celo blocks with Firehose and Substreams, or query archive state over JSON-RPC, using Pinax endpoints +--- + +This page is for app developers and data teams who need Celo data in bulk: full block streams, custom indexing pipelines, or historical state at any block. [Pinax](https://pinax.network/) runs its own Celo nodes and maintains the open source Firehose and Substreams stack alongside StreamingFast. + +## How it works + +[Firehose](https://app.pinax.network/docs/firehose) streams full blocks over gRPC, including transactions, receipts, logs, call traces, and balance changes. It carries more than a JSON-RPC node returns, and it reads history faster than sequential RPC calls. + +[Substreams](https://app.pinax.network/docs/substreams) runs on top of Firehose. You write modules in Rust, package them as an `.spkg` file, and run them on Pinax servers to turn raw blocks into the shape your application needs. Output can go to PostgreSQL or ClickHouse, stream to a consumer, or feed a Graph Node as a subgraph data source. + +[Pinax RPC](https://app.pinax.network/docs/rpc) serves standard Ethereum JSON-RPC 2.0 from archive nodes, so historical state is queryable at any block. + +## Celo mainnet + +| Service | Endpoint | Authentication | +| --- | --- | --- | +| Firehose | `celo.firehose.pinax.network:443` | `X-Api-Key` header | +| Substreams | `celo.substreams.pinax.network:443` | `SUBSTREAMS_API_KEY` | +| RPC | `https://celo.rpc.pinax.network` | API key | + +## Celo Sepolia + +| Service | Endpoint | Authentication | +| --- | --- | --- | +| RPC | `https://celosepolia.rpc.pinax.network` | API key | + + + Firehose and Substreams are available on Celo mainnet only. Celo Sepolia is served over RPC. + + +## Resources + +| Resource | Link | +| --- | --- | +| Pinax documentation | https://app.pinax.network/docs | +| Create an API key | https://app.pinax.network | +| Substreams CLI | https://docs.substreams.dev | +| Plans and pricing | https://pinax.network/en/pricing | + +## Related + +- [Indexers overview](/tooling/indexers/overview) - other indexing options on Celo, and when each one fits. +- [The Graph](/tooling/indexers/the-graph) - subgraphs, which can use Substreams as a data source. From e25c54c59405d42574ed1e716cd21984d4c2f843 Mon Sep 17 00:00:00 2001 From: Daniel Keyes <37008057+chillsauce@users.noreply.github.com> Date: Tue, 20 Oct 2026 17:19:40 -0400 Subject: [PATCH 2/3] docs: correct Firehose detail level for Celo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Celo blocks are served at Firehose's base detail level. The page claimed call traces and balance changes, which require extended blocks from an instrumented node — Pinax does not run one for Celo. Verified against the live stream, which reports DETAILLEVEL_BASE. --- build/tools/indexers/pinax.mdx | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/build/tools/indexers/pinax.mdx b/build/tools/indexers/pinax.mdx index a972544512..5eafa219f3 100644 --- a/build/tools/indexers/pinax.mdx +++ b/build/tools/indexers/pinax.mdx @@ -7,7 +7,9 @@ This page is for app developers and data teams who need Celo data in bulk: full ## How it works -[Firehose](https://app.pinax.network/docs/firehose) streams full blocks over gRPC, including transactions, receipts, logs, call traces, and balance changes. It carries more than a JSON-RPC node returns, and it reads history faster than sequential RPC calls. +[Firehose](https://app.pinax.network/docs/firehose) streams full blocks over gRPC, including transactions, receipts and logs, with cursors so a consumer can resume exactly where it stopped after a restart or a reorg. It reads history far faster than sequential RPC calls, and the same stream serves both historical and live blocks, so one integration covers backfill and tail. + +Celo blocks are served at Firehose's *base* detail level. Call traces, internal transfers and storage changes require an instrumented node producing *extended* blocks, which Pinax does not currently run for Celo. [Substreams](https://app.pinax.network/docs/substreams) runs on top of Firehose. You write modules in Rust, package them as an `.spkg` file, and run them on Pinax servers to turn raw blocks into the shape your application needs. Output can go to PostgreSQL or ClickHouse, stream to a consumer, or feed a Graph Node as a subgraph data source. From 1c54f4b35c929a219f1f5ddf267fe50351043a36 Mon Sep 17 00:00:00 2001 From: Daniel Keyes <37008057+chillsauce@users.noreply.github.com> Date: Fri, 23 Oct 2026 16:29:04 -0400 Subject: [PATCH 3/3] docs(indexers): source the Pinax claims and document keyless RPC Addresses the review on celo-org/docs#2372. - Cut "reads history far faster than sequential RPC calls" (unsourced comparison) and the unsourced StreamingFast co-maintenance claim; the intro now links the Substreams docs, which list Pinax as a provider. - Cite The Graph's networks registry for the base-detail-level statement ("evmExtendedModel": false, "blockFeatures": ["base"]) so the strongest technical claim on the page has a third-party source. - Split authentication into method and mechanism: SUBSTREAMS_API_KEY is where the CLI reads the key from, not an auth method. - Document that the RPC endpoints answer without a key. They do, on both networks; those requests take a rate-limited anonymous path served only from Pinax's own nodes with no fallback capacity. - Link pinax.network/chain/celo as the canonical endpoint list so the tables here are examples rather than a second source of truth. Co-Authored-By: Claude Opus 5 --- build/tools/indexers/pinax.mdx | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/build/tools/indexers/pinax.mdx b/build/tools/indexers/pinax.mdx index 5eafa219f3..3d9773d9cc 100644 --- a/build/tools/indexers/pinax.mdx +++ b/build/tools/indexers/pinax.mdx @@ -3,40 +3,49 @@ title: Pinax description: Stream Celo blocks with Firehose and Substreams, or query archive state over JSON-RPC, using Pinax endpoints --- -This page is for app developers and data teams who need Celo data in bulk: full block streams, custom indexing pipelines, or historical state at any block. [Pinax](https://pinax.network/) runs its own Celo nodes and maintains the open source Firehose and Substreams stack alongside StreamingFast. +This page is for app developers and data teams who need Celo data in bulk: full block streams, custom indexing pipelines, or historical state at any block. [Pinax](https://pinax.network/) runs its own Celo nodes and operates Firehose and Substreams endpoints; the Substreams documentation [lists Pinax among its providers](https://docs.substreams.dev/reference-material/chains-and-endpoints). ## How it works -[Firehose](https://app.pinax.network/docs/firehose) streams full blocks over gRPC, including transactions, receipts and logs, with cursors so a consumer can resume exactly where it stopped after a restart or a reorg. It reads history far faster than sequential RPC calls, and the same stream serves both historical and live blocks, so one integration covers backfill and tail. +[Firehose](https://app.pinax.network/docs/firehose) streams full blocks over gRPC, including transactions, receipts and logs, with cursors so a consumer can resume exactly where it stopped after a restart or a reorg. The same stream serves both historical and live blocks, so one integration covers backfill and tail. -Celo blocks are served at Firehose's *base* detail level. Call traces, internal transfers and storage changes require an instrumented node producing *extended* blocks, which Pinax does not currently run for Celo. +Celo blocks are served at Firehose's *base* detail level: call traces, internal transfers and storage changes are not included. Those *extended* fields are produced by an instrumented node, which Pinax does not currently run for Celo. The Graph's [networks registry](https://networks-registry.thegraph.com/TheGraphNetworksRegistry.json) records the same for Celo — `"evmExtendedModel": false` and `"blockFeatures": ["base"]`. [Substreams](https://app.pinax.network/docs/substreams) runs on top of Firehose. You write modules in Rust, package them as an `.spkg` file, and run them on Pinax servers to turn raw blocks into the shape your application needs. Output can go to PostgreSQL or ClickHouse, stream to a consumer, or feed a Graph Node as a subgraph data source. [Pinax RPC](https://app.pinax.network/docs/rpc) serves standard Ethereum JSON-RPC 2.0 from archive nodes, so historical state is queryable at any block. -## Celo mainnet +## Endpoints + +[pinax.network/chain/celo](https://pinax.network/chain/celo) is the canonical list of Pinax's Celo endpoints. The tables below are examples, and that page is the one to trust if they ever disagree. + +### Celo mainnet | Service | Endpoint | Authentication | | --- | --- | --- | -| Firehose | `celo.firehose.pinax.network:443` | `X-Api-Key` header | -| Substreams | `celo.substreams.pinax.network:443` | `SUBSTREAMS_API_KEY` | -| RPC | `https://celo.rpc.pinax.network` | API key | +| Firehose | `celo.firehose.pinax.network:443` | API key, sent as an `X-Api-Key` header | +| Substreams | `celo.substreams.pinax.network:443` | API key; the Substreams CLI reads it from `SUBSTREAMS_API_KEY` | +| RPC | `https://celo.rpc.pinax.network` | API key, optional — see below | -## Celo Sepolia +### Celo Sepolia | Service | Endpoint | Authentication | | --- | --- | --- | -| RPC | `https://celosepolia.rpc.pinax.network` | API key | +| RPC | `https://celosepolia.rpc.pinax.network` | API key, optional — see below | Firehose and Substreams are available on Celo mainnet only. Celo Sepolia is served over RPC. +### Calling RPC without an API key + +The RPC endpoints also answer unauthenticated requests, so an `eth_chainId` call with no key returns `0xa4ec` on mainnet and `0xaa044c` on Sepolia. Those requests take a rate-limited anonymous path, served only from Pinax's own nodes with no fallback capacity behind them. Send an API key for the full routing and for per-key rate limits — see the [RPC documentation](https://app.pinax.network/docs/rpc). + ## Resources | Resource | Link | | --- | --- | +| Celo endpoints on Pinax | https://pinax.network/chain/celo | | Pinax documentation | https://app.pinax.network/docs | | Create an API key | https://app.pinax.network | | Substreams CLI | https://docs.substreams.dev |