Skip to main content
Goldsky offers four products that cover different ways of working with blockchain data. Answer two questions in the chooser below, or start with the table and read the section for the product that matches your need. If you’d rather start from the outcome than the tooling, browse the use-case solutions (payments, compliance monitoring, reconciliation, tokenized assets), each of which walks you to the right product combination for that job.

​
Turbo pipelines

Turbo streams raw or transformed onchain data into infrastructure you control: PostgreSQL, ClickHouse, MySQL, Kafka, S3, webhooks, and more. You shape the data in flight with SQL and TypeScript transforms, and pipelines are reorg-aware with at-least-once delivery. Pick Turbo when:
  • You want full control over storage and querying, with chain data colocated alongside the rest of your business data.
  • You need to combine onchain and offchain data, or feed BI tools, analytics warehouses, and AI systems.
  • You’re building multi-chain, including non-EVM chains like Solana, Bitcoin, Stellar, and NEAR (see supported networks).
  • You need high throughput and fast backfills, with query latency limited only by your own database.
Look elsewhere when:
  • You just want a ready-made query API without operating a database: use Subgraphs.
  • You need direct node access rather than indexed datasets: use Edge RPC.
Introduction · Quickstart

​
Edge RPC

Edge RPC provides high-performance JSON-RPC endpoints for EVM networks: multi-region CDN, intelligent caching, automatic failover across providers, and built-in observability. Pick Edge RPC when:
  • Your indexer, backend, or frontend speaks JSON-RPC directly and needs low latency and high reliability.
  • You need archive access and batch requests tuned for high-throughput indexing.
  • You want to stop running or juggling your own node providers.
Look elsewhere when:
  • You need indexed, decoded, or transformed data in a queryable form: use Subgraphs or Turbo instead of re-deriving it from raw RPC calls.
Introduction · Quickstart

​
Compose

Compose is the offchain-to-onchain framework for high-stakes systems. You write durable TypeScript tasks that run in verifiable, auditable sandboxes, triggered by onchain events, cron schedules, or API calls, and able to write back onchain. Pick Compose when:
  • You’re building custom oracles, price/data feeds, or prediction market resolution.
  • You need keepers, scheduled tasks, circuit breakers, or cross-chain coordination.
  • You need guaranteed, traceable execution: every function call audited, optionally attested in a TEE.
Look elsewhere when:
  • You only need to read or deliver data, with no logic to execute. The other three products cover that.
Introduction · Quickstart

​
Subgraphs

Subgraphs give you a hosted, backwards-compatible subgraph indexing service. You define entities and mapping logic, and Goldsky runs the entire stack (indexing, storage, and an instant GraphQL API), with webhooks out of the box and support for custom EVM chains. Pick Subgraphs when:
  • You’re building a dApp frontend that queries structured onchain data through an API.
  • Your data model is entity-based and covered by onchain events and calls.
  • You want zero infrastructure to run, and query traffic is low to moderate.
  • You want to reuse the huge ecosystem of existing open-source subgraphs, or migrate one from another host.
Look elsewhere when:
  • You need the data in your own database or warehouse, or need to join it with offchain data: use Turbo.
  • You need non-EVM chains or very high event throughput. Subgraph latency grows as event frequency climbs.
Introduction · Deploy a subgraph

​
Subgraphs vs. Turbo

Both products index the same onchain data. The difference is who runs the serving layer and how flexible the data model is.
  • API vs. pipeline. Subgraphs give you a managed GraphQL API: Goldsky runs the indexing, the database, and the query layer. Turbo streams data into a database you manage, so you own the storage and query layer and can optimize or scale it however you like.
  • Data model. Subgraph entities are tailored to onchain EVM data, with expressive transformation logic in mapping handlers and eth_call enrichment, but no offchain data integration. Turbo is open to any data shape: combine chain data with your own data, pre-process with SQL or TypeScript transforms, and do heavier aggregation downstream in your database.
  • Scale. Subgraphs perform well at low to moderate event throughput; as event frequency climbs, latency grows and multi-chain setups often require reindexing. Turbo is built for horizontal scale, fast backfills, and multi-chain applications, including non-EVM chains.
  • Ecosystem. Subgraphs have a mature ecosystem of open-source examples, plus Goldsky’s no-code Instant Subgraphs. Turbo pipelines are simple YAML definitions backed by curated datasets, which makes them straightforward to generate and review, including with AI agents.
You don’t have to choose one: you can stream your subgraph’s entities into your own database with a subgraph entity source (currently a Mirror legacy feature), getting an instant GraphQL API and full control over your data at the same time.

​
Where’s Mirror?

Mirror is Goldsky’s original pipeline product. It’s now legacy, superseded by Turbo. Around 95% of Mirror pipelines map 1:1 onto Turbo, and existing Mirror pipelines keep running. See the Mirror legacy notice for what the remaining legacy docs cover, and the migration guide for a feature-by-feature path to Turbo.