The blockchain data marketplace

Buy Solana history.
Get Parquet files.

380 billion decoded instructions across 62 Solana programs, sold as 1,455 tables. Priced flat. Downloaded once. Yours forever. Chain data the way a data team would sell it — files, not API quotas.

Explore datasets Talk to our team

Pump.fun · Meteora · Raydium · Jupiter · Kamino + 20 more families — Hyperliquid next — see coverage

Search datasets⌘K

Research

Networks

Solana44

Families

Pump.fun1
Meteora3
Raydium4
Jupiter5

Pump.fun

Complete archiveCurrent

solana / pumpfun · 53 tables · 33.2M rows in sampled epochs

Sample dataRequest access

Type: Historical archive
Tables: 53 · 29 ix + 24 ev
Observed rows*: 33.2M sampled
Coverage: Apr 2024 → Jun 2026
Delivery: Parquet · Bulk / S3
Schema: v1.0

Table · solana.pump_fun.buyinstruction · 24 cols

Column preview for the pump_fun buy instruction table
Field	Type	Description
block_time	timestamp	slot time, UTC
signature	base58	transaction signature
mint	pubkey	token mint account
user	pubkey	buyer · signer
amount	u64	decoded arg
max_sol_cost	u64	decoded arg

View all 53 tables →

Sample recordsmost recent

312044817BUYHNDL4.2003xk9…f2Ru
312044811SELLPLYR1.8509mQe…aa71
312044809BUYORBIT0.620Ju2c…9dEw
312044792LAUNCHKILN—7prA…cc3M
312044790BUYKILN2.040Bb41…u8Xt

partitioned by date · parquetsample data

dataset: pumpfun · 53 tables · schema v1.0provenance: documented · coverage: reconciled

Depth first. Breadth later.

62 programs on Solana — Apr 2024 → Jun 2026 in the archive, back to genesis on request. Hyperliquid is next — we'd rather cover two chains properly than forty badly. Names indicate data coverage, not partnership or endorsement.

Networks

Solana62 programs · 1,455 tables
Hyperliquidcoming next

Protocol families

Why a marketplace

Every desk builds this same pipeline.
We built it once.

Every program has its own encoding. Every upgrade breaks somebody's decoder. So each firm quietly runs the same indexers, patches the same gaps, and re-runs the same backfills as the firm next door. We do that work once and sell the output — documented, versioned, and deliberately boring.

What teams maintain today

Archive nodes
RPC providers
Program IDLs
Contract ABIs
Custom indexers
Backfill jobs
CSV exports
Vendor APIs
Ad-hoc schemas

Per chain. Per protocol. Per team. Rebuilt whenever anything upstream changes.

One catalog

Discover
Search datasets by chain, protocol, entity, and category
Evaluate
Inspect schemas, provenance, lineage, and freshness
Access
Buy once; own the files as versioned Parquet

Into your stack

Parquet
Partitioned
Versioned
Bulk download
S3 / GCS drops

Research, backtesting, model training, monitoring, and production systems.

Dataset catalog

62 programs. 1,455 tables. One catalog.

One price buys every table in a dataset — all its instructions, all its events, full history. No per-table upsells. The deepest entries in the registry:

Browse all 62 datasets

62 datasets · 1,455 tables · 33 protocol families · every table documented

Explore the full catalog →

Historical coverage

Complete history, kept current.

An archive has two ends. It has to reach genesis without gaps, and it has to keep growing as you need more. Buy a window now, order a fresh cut whenever — and every build is reconciled against the chain to prove it.

Completeness

Archives that reach back to genesis

Complete protocol archives, reconciled against chain state
Backfills handled upstream — including after decoder changes
Point-in-time state for balances, pools, and positions
Bulk delivery sized for research and model training

Archive coverageApr 2024 → Jun 2026 · earlier on request

pump_fun.buyprogram genesis
meteora_dlmm.swapprogram genesis
orca_whirlpool.swapprogram genesis
raydium_clmm.swapprogram genesis

Freshness

Fresh cuts whenever you need them

Every order is cut fresh from the latest archive build
Need newer history later? Order a new window any time
Every delivery ships as an immutable version with a change log
Late data and reorgs reconciled before publication

Fresh cutsper order

pump_fun.buyon requestv1.0Current
meteora_dlmm.swapon requestv1.0Current
orca_whirlpool.swapon requestv1.0Current
jupiter_perpetuals.*on requestv1.0Current

corrections ship as new versionsImmutable

The pipeline

From raw bytes to tables you can query

Here is one transaction at four stages of the pipeline. Everything that lands in your bucket traces back to the raw instruction it came from. Byte for byte.

01Raw instruction

program: 6EF8rrec...P65p
accounts: [16]
data: 0x66063d1201daebea…
inner_ix: 3
slot: 312044817

02Decoded instruction

instruction: pump_fun.buy
mint: 8x1fUe…pump
user: 3xk9…f2Ru
amount: 118344021
max_sol_cost: 4200000000

03Table row

table: solana.pump_fun.buy
block_time: 2025-01-15 12:00:41
slot: 312044817
tx_index: 288 · ix_index: 2
schema: v1.0

04Published file

buy/schema=v1.0/
  date=2025-01-15/
    part-0000.parquet
+ manifest: sha256 per file
+ lineage: raw → v1.0

01
Raw capture
Blocks, transactions, logs, instructions, and traces captured directly from chain infrastructure.
02
Protocol decoding
Program- and venue-specific decoders turn opaque calldata into typed protocol events.
03
Validation & dedup
Records are checked against chain state, reorgs are resolved, and duplicates are removed.
04
Normalization
Events map onto consistent, documented schemas that hold across protocols and chains.
05
Entity resolution
Tokens, pools, programs, and wallets are resolved to stable identifiers with metadata.
06
Enrichment
Records gain context — pool state, token metadata, pricing references, related events.
07
Versioned publication
Datasets ship with schema versions, lineage records, and change logs. Nothing mutates silently.
08
Delivery — files or firehose
The pipeline forks: datasets publish as partitioned, versioned Parquet for download or cloud drops — and the same decoded tables stream live into your own Kafka, ClickHouse, NATS, or S3.

Quality & provenance

Trust that comes from the data, not the pitch

Every dataset carries its own evidence — source, transforms, version, completeness. It's all in the manifest, with a checksum per file. Check it. Don't take our word for anything.

Documented provenance: Every dataset records where its raw inputs came from and every transformation applied to them.
Versioned schemas: Schemas evolve through explicit versions with change logs. Breaking changes never land silently.
Dataset lineage: Derived datasets reference their upstream sources, so you can trace any record back to raw chain data.
Completeness reconciliation: Archives are continuously reconciled against chain state to detect and repair gaps.
Deterministic processing: Transformations are reproducible: the same raw inputs always produce the same published records.
Deduplication & validation: Records are validated against protocol rules and deduplicated across capture paths before publication.
Freshness indicators: Each dataset exposes when it was last updated and how far its coverage extends, so pipelines can act on staleness.
Immutable versions: Published dataset versions never change under you; corrections ship as new versions with change logs.

pumpfun_trades.manifest

Verified lineage

dataset: solana/pumpfun_trades
schema_version: 3.2
stage: normalized

lineage:
  - source: solana.raw_instructions
  - transform: pumpfun_decoder@2.8
  - transform: dedup_reorg_resolver
  - transform: dex_trade_normalizer

checks:
  reconciliation: continuous
  deduplication:  enforced
  reorg_handling: resolved
  determinism:    reproducible

changelog:
  v3.2  add curve_phase field
  v3.1  entity-resolved mints
  v3.0  unified trade schema

Every published dataset ships with a manifest like this one.

Delivery

One format, deliberately: Parquet.

We sell datasets, not access tiers. No metered queries, no rate limits, no renewal hostage-taking — partitioned Parquet you download once and keep. Query it with whatever your team already runs.

dataset-layout · text

s3://datastore-delivery/<org>/solana/pump_fun/
  buy/
    schema=v1.0/
      date=.../part-0000.parquet
      ...
  sell/
    schema=v1.0/...
  _manifests/
    buy.v1.0.manifest.json

Every dataset is a deterministic file tree: partitioned by date, pinned to a schema version, and described by a manifest with checksums. No proprietary formats, no lock-in.

Parquet reads natively in

SparkDuckDBClickHouseSnowflakeBigQuerypandas / Polars

Build vs. buy

The pipeline you don't have to own

An in-house chain pipeline isn't a project. It's a headcount, forever. Here's the trade, line by line.

Area

Maintaining it internally

With datastore.sh

Chain indexers

Run and monitor archive nodes and indexers for every chain you cover, through every upgrade.

Consume maintained datasets; node operations and indexer upkeep stay on our side.

Protocol decoders

Reverse-engineer program layouts and venue APIs, then track every protocol release.

Decoded events arrive typed and documented, updated as protocols change.

Historical backfills

Re-run multi-month backfills whenever a decoder changes or a gap is discovered.

Backfills and gap repair happen upstream; you receive versioned, reconciled archives.

Schema drift

Absorb breaking protocol changes into your own schemas, per team, per pipeline.

Consistent schemas across chains with explicit versioning and change logs.

New coverage

Each new venue or protocol is a fresh engineering project before analysis can start.

New coverage is a catalog entry — evaluate the schema, then subscribe.

Team focus

Data engineers spend their time keeping pipelines alive instead of shipping analysis.

Your team starts from decoded tables and spends its time on what actually differentiates you.

Enterprise

Built for teams with obligations

When on-chain data feeds trading systems, risk models, and production applications, it stops being a convenience and starts being a dependency. datastore.sh is operated accordingly — with the controls, delivery options, and support model that institutional workloads require.

Discuss enterprise requirements Browse the catalog

Volume without ceremony: Full-history archives delivered at the scale quantitative research and model-training workloads actually require.
Governance & access control: Organization-level controls over who can access which datasets, with auditable usage records.
Delivery into your cloud: Parquet drops into object storage you control, so data lands where your governance already applies.
Private & dedicated options: Dedicated pipelines and private deployment models for teams with isolation requirements.
Named technical support: Direct access to the engineers responsible for the datasets you depend on — not a ticket queue.
Clear operational ownership: Published processing status, incident communication, and explicit ownership of every dataset we operate.

From the team

How the data is actually made

All updates

Engineering

Inside the indexing architecture behind our Solana coverage

How we capture instructions, inner instructions, and account state at slot granularity across every program we decode — and keep decoders current through upgrades.

9 min read

Methodology