---
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](https://datastore.sh). The full [Pump.fun Swaps dataset](https://datastore.sh/datasets/pump-swap) has 23 tables and is delivered as Parquet. The same sample is also on [Kaggle](https://www.kaggle.com/datasets/datastore90/pumpswap-amm-historical-data-sample) and [GitHub](https://github.com/DataStore100/pumpswap-amm-historical-data-sample).

## 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

```python
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`:

```python
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](https://datastore.sh/datasets/pump-swap) 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](https://datastore.sh/datasets/pumpfun) and [Pump.fun Fees](https://datastore.sh/datasets/pump-fees). [Browse the Solana catalog](https://datastore.sh/solana).

## License

[CC BY-SA 4.0](https://creativecommons.org/licenses/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