> ## Documentation Index
> Fetch the complete documentation index at: https://docs.goldsky.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Which product do I need?

> Choose between Turbo pipelines, Edge RPC, Compose, and Subgraphs based on what you're building.

export const ProductChooser = () => {
  const [dark, setDark] = useState(true);
  useEffect(() => {
    const root = document.documentElement;
    const update = () => setDark(root.classList.contains('dark'));
    update();
    const obs = new MutationObserver(update);
    obs.observe(root, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => obs.disconnect();
  }, []);
  const BTN_GOLD = '#FFAD33';
  const GOLD = dark ? '#FFAD33' : '#8A5300';
  const BORDER = dark ? 'rgba(161, 161, 170, 0.22)' : 'rgba(113, 113, 122, 0.28)';
  const MUTED = dark ? 'rgba(161, 161, 170, 0.95)' : 'rgba(82, 82, 91, 0.95)';
  const CARD_BG = dark ? 'rgba(24, 24, 27, 0.45)' : 'rgba(255, 255, 255, 0.65)';
  const HIGHLIGHT = dark ? 'rgba(255, 173, 51, 0.14)' : 'rgba(255, 173, 51, 0.16)';
  const [path, setPath] = useState('');
  const [detail, setDetail] = useState('');
  const PATHS = [{
    key: 'streaming',
    label: 'Streaming data in my own database',
    hint: 'Chain data landing in infra you control',
    question: 'Where should the data land?',
    options: [{
      key: 'postgres',
      label: 'Postgres or MySQL',
      rec: {
        product: 'Turbo',
        tagline: 'Streaming pipelines into your database',
        blurb: 'Define a pipeline in YAML — source, optional SQL or TypeScript transforms, and a Postgres or MySQL sink — and Goldsky streams reorg-aware chain data into your tables.',
        primary: {
          label: 'Turbo quickstart',
          href: '/turbo-pipelines/quickstart'
        },
        secondary: [{
          label: 'Postgres sink',
          href: '/turbo-pipelines/sinks/postgres'
        }],
        also: ''
      }
    }, {
      key: 'warehouse',
      label: 'ClickHouse or a warehouse',
      rec: {
        product: 'Turbo',
        tagline: 'Streaming pipelines into your warehouse',
        blurb: 'Stream decoded, transformed chain data into ClickHouse or object storage for analytics — with fast backfills and delivery guarantees.',
        primary: {
          label: 'Turbo quickstart',
          href: '/turbo-pipelines/quickstart'
        },
        secondary: [{
          label: 'ClickHouse sink',
          href: '/turbo-pipelines/sinks/clickhouse'
        }, {
          label: 'S3 sink',
          href: '/turbo-pipelines/sinks/s3'
        }],
        also: ''
      }
    }, {
      key: 'queue',
      label: 'Kafka, a queue, or webhooks',
      rec: {
        product: 'Turbo',
        tagline: 'Streaming pipelines into your event bus',
        blurb: 'Push every matching event to Kafka, SQS, Pub/Sub, or an HTTP webhook — with throttling and at-least-once delivery for downstream consumers.',
        primary: {
          label: 'Turbo quickstart',
          href: '/turbo-pipelines/quickstart'
        },
        secondary: [{
          label: 'Kafka sink',
          href: '/turbo-pipelines/sinks/kafka'
        }, {
          label: 'Webhook sink',
          href: '/turbo-pipelines/sinks/webhook'
        }],
        also: ''
      }
    }]
  }, {
    key: 'rpc',
    label: 'Raw RPC access to a chain',
    hint: 'Low-latency JSON-RPC endpoints',
    question: "What's hitting the endpoint?",
    options: [{
      key: 'indexer',
      label: 'An indexer or backend at high throughput',
      rec: {
        product: 'Edge RPC',
        tagline: 'RPC tuned for indexing workloads',
        blurb: 'Archive access, batch requests, and automatic failover across providers — built for backfills and high-throughput backends.',
        primary: {
          label: 'Edge RPC quickstart',
          href: '/edge-rpc/quickstart'
        },
        secondary: [{
          label: 'Why Edge',
          href: '/edge-rpc/why-edge'
        }],
        also: 'Re-deriving decoded data from raw calls? Turbo may save you the work.'
      }
    }, {
      key: 'frontend',
      label: 'A frontend app',
      rec: {
        product: 'Edge RPC',
        tagline: 'Cached, multi-region RPC for apps',
        blurb: 'Smart caching and request deduplication over a multi-region CDN keep wallet balances and reads responsive for end users.',
        primary: {
          label: 'Edge RPC quickstart',
          href: '/edge-rpc/quickstart'
        },
        secondary: [{
          label: 'Edge RPC introduction',
          href: '/edge-rpc/introduction'
        }],
        also: ''
      }
    }, {
      key: 'x402',
      label: 'Pay-per-request, no account',
      rec: {
        product: 'Edge RPC',
        tagline: 'x402 nanopayments',
        blurb: 'Pay for RPC per request with x402 — no signup, no API key, no subscription. Ideal for agents and scripts.',
        primary: {
          label: 'x402 nanopayments',
          href: '/edge-rpc/capabilities/x402'
        },
        secondary: [{
          label: 'Edge RPC introduction',
          href: '/edge-rpc/introduction'
        }],
        also: ''
      }
    }]
  }, {
    key: 'automation',
    label: 'Onchain automation & execution',
    hint: 'Oracles, keepers, offchain-to-onchain logic',
    question: 'What are you automating?',
    options: [{
      key: 'oracle',
      label: 'An oracle or price/data feed',
      rec: {
        product: 'Compose',
        tagline: 'Durable tasks that write onchain',
        blurb: 'Write TypeScript tasks that ingest data, apply your logic, and publish results onchain — traced end to end, optionally attested in a TEE.',
        primary: {
          label: 'Compose quickstart',
          href: '/compose/quick-start'
        },
        secondary: [{
          label: 'Build a NAV oracle',
          href: '/compose/guides/build-a-nav-oracle'
        }],
        also: ''
      }
    }, {
      key: 'keeper',
      label: 'Keepers or scheduled jobs',
      rec: {
        product: 'Compose',
        tagline: 'Triggered, guaranteed execution',
        blurb: 'Trigger tasks from onchain events, cron schedules, or API calls, with durable retries and full tracing of every external call.',
        primary: {
          label: 'Compose quickstart',
          href: '/compose/quick-start'
        },
        secondary: [{
          label: 'Task triggers',
          href: '/compose/task-triggers'
        }],
        also: ''
      }
    }, {
      key: 'compliance',
      label: 'Compliance screening & attestations',
      rec: {
        product: 'Compose',
        tagline: 'Provable compliance workflows',
        blurb: 'Screen transactions against AML providers, gate payments on the result, and keep an audit trail that proves your logic ran as written.',
        primary: {
          label: 'Build a compliance oracle',
          href: '/compose/guides/build-a-compliance-oracle'
        },
        secondary: [{
          label: 'Compose quickstart',
          href: '/compose/quick-start'
        }],
        also: ''
      }
    }]
  }, {
    key: 'graphql',
    label: 'A GraphQL API on my contracts',
    hint: 'Hosted queries for a dApp or backend',
    question: 'How do you want to define the API?',
    options: [{
      key: 'nocode',
      label: 'No code — I have contract addresses and ABIs',
      rec: {
        product: 'Subgraphs',
        tagline: 'Instant subgraphs from a config file',
        blurb: 'Describe your contracts in a small JSON config and Goldsky indexes them into a hosted GraphQL API — no mapping code, no infrastructure.',
        primary: {
          label: 'Create a no-code subgraph',
          href: '/subgraphs/guides/create-a-no-code-subgraph'
        },
        secondary: [{
          label: 'Subgraphs introduction',
          href: '/subgraphs/introduction'
        }],
        also: 'Need the same data in your own database later? Stream it out with Turbo.'
      }
    }, {
      key: 'custom',
      label: 'Full subgraph with custom mapping logic',
      rec: {
        product: 'Subgraphs',
        tagline: 'Backwards-compatible hosted indexing',
        blurb: 'Write standard subgraph entities and AssemblyScript mappings; Goldsky runs the indexing, storage, and an autoscaling GraphQL layer with webhooks built in.',
        primary: {
          label: 'Deploy a subgraph',
          href: '/subgraphs/deploying-subgraphs'
        },
        secondary: [{
          label: 'Subgraphs introduction',
          href: '/subgraphs/introduction'
        }],
        also: 'High event throughput or non-EVM chains? Consider Turbo instead.'
      }
    }, {
      key: 'migrate',
      label: 'I already run one on another host',
      rec: {
        product: 'Subgraphs',
        tagline: 'Migrate an existing subgraph',
        blurb: 'Goldsky is fully backwards-compatible with The Graph — most migrations are a single CLI command, and there are dedicated guides for Alchemy.',
        primary: {
          label: 'Migrate from The Graph',
          href: '/subgraphs/migrate-from-the-graph'
        },
        secondary: [{
          label: 'Migrate from Alchemy',
          href: '/subgraphs/migrate-from-alchemy/guide'
        }],
        also: ''
      }
    }]
  }];
  const activePath = PATHS.find(p => p.key === path);
  const activeRec = activePath?.options.find(o => o.key === detail)?.rec;
  const stepLabel = {
    fontSize: 11,
    fontWeight: 600,
    letterSpacing: 1,
    textTransform: 'uppercase',
    color: GOLD,
    margin: '0 0 8px'
  };
  const optionBtn = selected => ({
    display: 'block',
    width: '100%',
    textAlign: 'left',
    padding: '12px 14px',
    borderRadius: 10,
    border: `1px solid ${selected ? GOLD : BORDER}`,
    background: selected ? HIGHLIGHT : CARD_BG,
    color: 'inherit',
    cursor: 'pointer',
    fontSize: 14,
    lineHeight: 1.4,
    transition: 'border-color .15s ease'
  });
  const smallBtn = {
    padding: '6px 12px',
    borderRadius: 8,
    border: `1px solid ${BORDER}`,
    background: 'transparent',
    color: MUTED,
    cursor: 'pointer',
    fontSize: 12
  };
  return <div style={{
    border: `1px solid ${BORDER}`,
    borderRadius: 14,
    padding: '18px 20px 20px',
    background: CARD_BG,
    margin: '8px 0 4px'
  }}>
      {!activePath ? <div>
          <div style={stepLabel}>Step 1 of 2 · What do you need?</div>
          <div style={{
    display: 'grid',
    gridTemplateColumns: 'repeat(auto-fit, minmax(230px, 1fr))',
    gap: 10
  }}>
            {PATHS.map(p => <button key={p.key} type="button" style={optionBtn(false)} onClick={() => setPath(p.key)}>
                <span style={{
    fontWeight: 600,
    display: 'block'
  }}>{p.label}</span>
                <span style={{
    color: MUTED,
    fontSize: 12
  }}>{p.hint}</span>
              </button>)}
          </div>
        </div> : !activeRec ? <div>
          <div style={stepLabel}>Step 2 of 2 · {activePath.question}</div>
          <div style={{
    display: 'grid',
    gridTemplateColumns: 'repeat(auto-fit, minmax(230px, 1fr))',
    gap: 10
  }}>
            {activePath.options.map(o => <button key={o.key} type="button" style={optionBtn(false)} onClick={() => setDetail(o.key)}>
                <span style={{
    fontWeight: 600
  }}>{o.label}</span>
              </button>)}
          </div>
          <div style={{
    marginTop: 12
  }}>
            <button type="button" style={smallBtn} onClick={() => setPath('')}>
              ← Back
            </button>
          </div>
        </div> : <div>
          <div style={stepLabel}>Our recommendation</div>
          <div style={{
    border: `1px solid ${GOLD}66`,
    borderRadius: 12,
    padding: '16px 18px',
    background: HIGHLIGHT
  }}>
            <div style={{
    margin: 0,
    fontSize: 20,
    fontWeight: 600
  }}>
              {activeRec.product}
              <span style={{
    color: MUTED,
    fontWeight: 400,
    fontSize: 14,
    marginLeft: 10
  }}>{activeRec.tagline}</span>
            </div>
            <div style={{
    margin: '8px 0 14px',
    fontSize: 14,
    lineHeight: 1.55
  }}>{activeRec.blurb}</div>
            <div style={{
    display: 'flex',
    gap: 10,
    alignItems: 'center',
    flexWrap: 'wrap'
  }}>
              <a href={activeRec.primary.href} style={{
    display: 'inline-block',
    padding: '8px 16px',
    borderRadius: 999,
    background: BTN_GOLD,
    color: '#090B0C',
    fontWeight: 600,
    fontSize: 13,
    textDecoration: 'none'
  }}>
                {activeRec.primary.label} →
              </a>
              {activeRec.secondary.map(s => <a key={s.href} href={s.href} style={{
    color: GOLD,
    fontSize: 13
  }}>
                  {s.label}
                </a>)}
            </div>
            {activeRec.also ? <div style={{
    margin: '12px 0 0',
    color: MUTED,
    fontSize: 12
  }}>
                {activeRec.also} See <a href="/which-product" style={{
    color: GOLD
  }}>the full comparison</a>.
              </div> : <div style={{
    margin: '12px 0 0',
    color: MUTED,
    fontSize: 12
  }}>
                Products combine well — see <a href="/which-product" style={{
    color: GOLD
  }}>the full comparison</a> for
                how.
              </div>}
          </div>
          <div style={{
    marginTop: 12,
    display: 'flex',
    gap: 8
  }}>
            <button type="button" style={smallBtn} onClick={() => setDetail('')}>
              ← Back
            </button>
            <button type="button" style={smallBtn} onClick={() => {
    setPath('');
    setDetail('');
  }}>
              Start over
            </button>
          </div>
        </div>}
    </div>;
};

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](/solutions/payments-fintech) (payments, compliance monitoring, reconciliation, tokenized assets), each of which walks you to the right product combination for that job.

<ProductChooser />

| You need                                                                           | Use                                 |
| ---------------------------------------------------------------------------------- | ----------------------------------- |
| Streamed, transformed chain data landing in your own database, warehouse, or queue | [Turbo pipelines](#turbo-pipelines) |
| Raw, low-latency JSON-RPC access to chain nodes                                    | [Edge RPC](#edge-rpc)               |
| To execute onchain and offchain logic: oracles, keepers, automation                | [Compose](#compose)                 |
| A hosted GraphQL API to power a dApp frontend                                      | [Subgraphs](#subgraphs)             |

## Turbo pipelines

[Turbo](/turbo-pipelines/introduction) 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](/turbo-pipelines/delivery-guarantees).

**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](/chains/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](#subgraphs).
* You need direct node access rather than indexed datasets: use [Edge RPC](#edge-rpc).

[Introduction](/turbo-pipelines/introduction) · [Quickstart](/turbo-pipelines/quickstart)

## Edge RPC

[Edge RPC](/edge-rpc/introduction) 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](#subgraphs) or [Turbo](#turbo-pipelines) instead of re-deriving it from raw RPC calls.

[Introduction](/edge-rpc/introduction) · [Quickstart](/edge-rpc/quickstart)

## Compose

[Compose](/compose/introduction) 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](/compose/introduction) · [Quickstart](/compose/quick-start)

## Subgraphs

[Subgraphs](/subgraphs/introduction) 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](#turbo-pipelines).
* You need non-EVM chains or very high event throughput. Subgraph latency grows as event frequency climbs.

[Introduction](/subgraphs/introduction) · [Deploy a subgraph](/subgraphs/deploying-subgraphs)

## 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](/turbo-pipelines/transforms/sql) or [TypeScript](/turbo-pipelines/transforms/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](/subgraphs/guides/create-a-no-code-subgraph). Turbo pipelines are simple YAML definitions backed by [curated datasets](/chains/supported-networks), 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](/mirror/sources/subgraphs) (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](/mirror/introduction) for what the remaining legacy docs cover, and the [migration guide](/turbo-pipelines/migrate-from-mirror) for a feature-by-feature path to Turbo.


## Related topics

- [Supported networks](/chains/supported-networks.md)
- [Introduction to Goldsky](/introduction.md)
- [Migrate from Mirror to Turbo](/turbo-pipelines/migrate-from-mirror.md)
- [Installation](/installation.md)
- [Stream onchain data with Turbo](/turbo-pipelines/introduction.md)