Datasets:

DataStore
/

pumpswap-amm-historical-data-sample

license: cc-by-sa-4.0
pretty_name: Pump.fun PumpSwap AMM Historical Data Sample
language:
  - en
tags:
  - solana
  - pumpfun
  - pumpswap
  - defi
  - dex
  - amm
  - blockchain
  - crypto
  - onchain-data
size_categories:
  - 1K<n<10K
configs:
  - config_name: buy_event
    data_files: pump_swaps_buy_event.parquet
    default: true
  - config_name: sell_event
    data_files: pump_swaps_sell_event.parquet
  - config_name: buy
    data_files: pump_swaps_buy.parquet
  - config_name: buy_exact_quote_in
    data_files: pump_swaps_buy_exact_quote_in.parquet
  - config_name: sell
    data_files: pump_swaps_sell.parquet
  - config_name: cpi_event
    data_files: pump_swap_cpi_event.parquet

Pump.fun PumpSwap AMM Historical Data Sample

Solana's Pump.fun AMM: buy/sell instructions, trade events, fees and reserves.

This dataset has 6,000 rows of decoded PumpSwap data from Solana, the AMM that Pump.fun tokens trade on after they leave the bonding curve. It covers buy and sell instructions, the trade events each one emitted, and the raw event log, all from slots 425,520,001 to 425,520,072 on 10 June 2026 (09:38:33 to 09:39:01 UTC). Every trade includes the pool, trader, mints, amounts, the LP, protocol and creator fee split, and pool reserves after the trade.

It's a free sample from datastore.sh. The full Pump.fun Swaps dataset has 23 tables and is delivered as Parquet. The same sample is also on Kaggle and GitHub.

What is PumpSwap?

PumpSwap is Pump.fun's own constant-product AMM on Solana, program ID pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA. When a Pump.fun token completes its bonding curve, its liquidity moves into a PumpSwap pool, and trading continues there. Other pools can be created on it too, which is why not every token in this sample ends in "pump".

Files

All files are Parquet. There are two kinds of data here: what the trader asked for (instructions) and what actually happened (events).

pump_swaps_buy.parquet (1,000 rows, 33 columns) buy instructions: the trader names how many base tokens they want and the most quote they'll pay. Includes every account passed to the instruction. 82 pools, 541 traders.

pump_swaps_buy_exact_quote_in.parquet (1,000 rows, 33 columns) buy_exact_quote_in instructions: the trader names how much quote to spend and the fewest base tokens they'll accept. 99 pools, 590 traders.

pump_swaps_sell.parquet (1,000 rows, 30 columns) sell instructions: base tokens in, minimum quote out. 130 pools, 771 traders.

pump_swaps_buy_event.parquet (1,000 rows, 38 columns) The BuyEvent logged by both buy instructions, with actual amounts, fees and reserves. ix_name tells you which instruction produced it (557 buy, 443 buy_exact_quote_in).

pump_swaps_sell_event.parquet (1,000 rows, 31 columns) The SellEvent logged by each sell, with actual amounts, fees and reserves. 134 pools, 758 traders.

pump_swap_cpi_event.parquet (1,000 rows, 12 columns) Every event the program logged, as raw JSON: 522 BuyEvent, 430 SellEvent, 36 CloseUserVolumeAccumulatorEvent, 10 ClaimCashbackEvent and 2 InitUserVolumeAccumulatorEvent. It's the only file with the volume-tracking and cashback events.

How the files connect

Instruction to event: join on sig + ix_path. In this sample, all 557 buy rows and all 443 buy_exact_quote_in rows in the buy event file match an instruction row.
Event to raw log: drop the last element of the CPI file's ix_path and join on sig + that path. All 522 buys and 430 sells match.

Each file is its own 1,000-row cut, so their time windows end at slightly different slots and some rows near the end won't have a partner in the other file.

Load it

import pandas as pd, json

path = "hf://datasets/DataStore/pumpswap-amm-historical-data-sample/"
buys = pd.read_parquet(path + "pump_swaps_buy.parquet")
buy_events = pd.read_parquet(path + "pump_swaps_buy_event.parquet")
sell_events = pd.read_parquet(path + "pump_swaps_sell_event.parquet")
cpi = pd.read_parquet(path + "pump_swap_cpi_event.parquet")

# ix_path is stored as an array; make it a tuple so pandas can join on it
for df in (buys, buy_events, sell_events, cpi):
    df["ix_path"] = df["ix_path"].apply(tuple)

# Instruction row + the event it emitted: same transaction, same instruction path
trades = buys.merge(buy_events, on=["sig", "ix_path"], suffixes=("", "_event"))

# Event + its raw log: the CPI ix_path is one level below the event's
cpi["parent_ix"] = cpi["ix_path"].apply(lambda p: p[:-1])
sells_raw = sell_events.merge(cpi, left_on=["sig", "ix_path"], right_on=["sig", "parent_ix"], suffixes=("", "_cpi"))

# Pool spot price after each sell (raw units, before decimals)
sell_events["price_raw"] = sell_events["pool_quote_token_reserves"] / sell_events["pool_base_token_reserves"]

# Total fee on each sell, in quote-token base units
sell_events["total_fee"] = sell_events[["lp_fee", "protocol_fee", "coin_creator_fee"]].sum(axis=1)

# Event names in the raw log
cpi["event"] = cpi["data"].apply(lambda s: next(iter(json.loads(s))))
print(cpi["event"].value_counts())

Or load one table with the datasets library. Config names are buy_event (default), sell_event, buy, buy_exact_quote_in, sell and cpi_event:

from datasets import load_dataset

sell_events = load_dataset("DataStore/pumpswap-amm-historical-data-sample", "sell_event", split="train")

How the fees add up

On every sell in this sample, the trader receives quote_amount_out minus lp_fee, protocol_fee, coin_creator_fee and cashback, which equals user_quote_amount_out. For buys from the buy instruction, the trader pays quote_amount_in_with_lp_fee plus protocol_fee, coin_creator_fee and cashback, which equals user_quote_amount_in. Rows from buy_exact_quote_in don't follow that formula, so check them separately.

Fee rates vary by pool. In this sample the LP fee is 2, 20 or 25 basis points, the protocol fee is 5 or 93, and the creator fee runs from 0 to 95. coin_creator is 11111111111111111111111111111111 (the system program, meaning no creator is set) on 69% of sells.

Read this before you analyze

Amounts are raw integers in token base units. Divide by each mint's decimals before comparing tokens.
Don't assume the quote token is SOL. Pools of tokens that graduated from Pump.fun have the token as base and wrapped SOL as quote. Other pools can be the other way round, and a few very busy pools with wrapped SOL as base make up most instruction rows in this sample. Check base_mint and quote_mint on every row before you decide which side is the "token".
ix_path is an array column. Convert it to a tuple (as in the snippet above) before joining or grouping on it.
Addresses in JSON columns are 32-byte arrays. That applies to data in the CPI file and remaining in the instruction files. Convert them to base58 to compare with the other columns.
The sample covers under 30 seconds. Use it to learn the schema, build joins or test a pipeline. Price history, volume trends and backtests need a longer window.

Things worth trying

Compare the price a trader was willing to accept (max_quote_amount_in, min_quote_amount_out) with what they actually got, and you have slippage tolerance by trader. Split fee revenue three ways between LPs, protocol and coin creators. Or find the wallets that hit the same pool within a slot and see who got the better price.

Where can I get full PumpSwap history?

The Pump.fun Swaps dataset on datastore.sh covers 23 tables as partitioned Parquet with typed schemas, manifests and SHA-256 checksums. Pick a recent window or full history, keep the files, and query them without an API quota. For tokens before they migrate, see the Pump.fun bonding curve dataset and Pump.fun Fees. Browse the Solana catalog.

License

CC BY-SA 4.0

Citation

If you use this data, please credit and link to datastore.sh:

datastore.sh (2026). Pump.fun PumpSwap AMM Historical Data Sample. https://datastore.sh/datasets/pump-swap