· Checked November 18, 2026

Build your own Solana indexer or use a hosted one?

Build your own Solana indexer when you need programs a hosted indexer does not cover, provisional data before confirmation, or full control over the schema. Use a hosted indexer when its coverage and timing already meet your needs. The deciding factor is rarely code. It is who runs ingestion, reorg handling, backfill and on-call afterwards.

What an indexer is made of#

  1. Ingest: receiving data, from raw shreds, a stream or RPC.
  2. Decode: turning transactions into program-level events.
  3. Schema: the tables and keys those events land in.
  4. Storage: a database sized for write rate and query patterns.
  5. Confirmation and reorg handling: marking rows confirmed, failed or dropped as the chain settles.
  6. Backfill: loading history from before you connected, and joining it to the live data without gaps.
  7. Program upgrades: noticing when a program changes and updating its decoder.
  8. Operations: monitoring, alerts and someone on call.

Who carries each component#

ComponentBuild on raw shredsHosted indexerOpen indexing framework
IngestYou run a UDP receiverProviderFramework provider or you
DecodeYou, per programProvider, for supported programsYou write the modules
SchemaYours to designProvider's schemaYours, within the framework
StorageYou run itProviderA sink you choose, such as Postgres
Confirmation and reorgsYou reconcile against RPCProviderFramework handles some of it
BackfillYou, from RPC or archivesProviderFramework can replay history
Program upgradesYou notice and fixProvider, on their timelineYou update your modules
Execution resultsNot in shreds; fetch separatelyUsually includedDepends on the data source
On-callYour team for everythingProvider for their partShared

The right hand columns are not free of work. They move work to someone else's schedule and constrain you to their schema and program list.

When hosted wins#

  • The programs you care about are already covered and the provider's schema fits your queries.
  • You need execution results on every row, such as balances, logs or swap outputs. Raw shreds never carry these (E4 tech facts X-02).
  • Your team cannot staff on-call for a data pipeline.
  • History matters more than earliness, and the provider already holds it.

When building wins#

  • You decode programs nobody else covers, including your own.
  • You want rows before confirmation, marked as provisional, so your product can react early. The provisional rows model shows how to keep those rows honest.
  • You need a schema shaped around your queries, not a general one.
  • You want to keep raw inputs so you can re-decode history when a decoder bug is fixed.

A raw feed gives you signed transactions in leader order and nothing more (E4 tech facts X-01). The decoding pipeline and a store such as ClickHouse for chain data are where most of the build effort goes.

A hybrid many teams land on#

Run your own early layer for the few programs that matter most, and use a hosted or RPC source for confirmation, execution results and history. Your rows start provisional from shreds and are upgraded when the execution source catches up. This keeps the custom part small while keeping the early signal. The choice between databases for that pattern is covered in ClickHouse or Postgres.

Questions before you decide#

Can I build an indexer from shreds alone?#

You can index what transactions asked to do, but not what happened. Success, balances and logs come from execution, so a complete indexer adds an execution source.

How do I handle a slot that never finalizes?#

Keep rows from that slot provisional and drop them when your confirmation source shows the slot was skipped. Under Alpenglow, finality comes from certificates rather than from the shreds themselves (E4 tech facts X-04).

Does a hosted indexer remove the need for backfill planning?#

Only if it already holds the history you need, in the schema you need. Otherwise you are back to loading and joining it yourself.

What is the hidden cost of building?#

Program upgrades. Each upgrade can change instruction layouts, and a decoder that guesses wrong produces plausible but false rows.

When building on raw shreds is a mistake#

  • You need balances or swap outputs for every row and do not want a second source.
  • You need years of history on day one.
  • No one on the team can maintain decoders when programs change.
  • Your queries fit a hosted schema already.

In those cases, a hosted indexer or a parsed transaction API is the better use of your time.

Keep reading#

For the ownership question layer by layer, read raw feed or managed stream. For the bigger map of sources, see where Solana data comes from. If you decide to build, the Standard Shreds plan gives you the raw input.

Sources#

Raw shreds on your own server

Ultra Low Latency Shreds is $200 and Standard Shreds is $100. You pay in crypto, tell us which IPv4 address and UDP port should receive the stream, and we wire it up by hand.