Pump.fun vs PumpSwap AMM: Comparing On-Chain Trading Data

Why the bonding curve is safer

On the Pump.fun bonding curve, the smart contract itself is the market maker. It holds all the SOL and all the tokens. The creator cannot drain the pool, cannot freeze trading, and cannot mint more tokens. The only way to move the price is through buying and selling.

This makes the bonding curve phase relatively safe compared to the open AMM. The worst that can happen is that everyone sells and the price goes to near zero, but that is market risk, not a rug pull. Nobody can pull liquidity out from under you because the contract does not allow it.

You can verify this in the data. Every bonding curve token has a can_be_frozen field. On the bonding curve, this is almost always false. The token creator has no special powers over the contract.

What changes on PumpSwap AMM

Once a token graduates to PumpSwap, the rules change. The AMM is an open protocol where anyone can create a pool for any token. This introduces several risks that do not exist on the bonding curve.

• Freeze authority. Token creators can set freeze authority on their token mint. This lets them freeze any wallet's token balance, which effectively stops that wallet from selling. If can_be_frozen is true, the creator has this power.
• Liquidity removal. On the AMM, liquidity providers can withdraw their liquidity at any time. If the token creator added the initial liquidity, they can pull it out and crash the price to zero. This is the classic rug pull.
• Anyone can create pools. Unlike the bonding curve where only the Pump.fun contract creates markets, anyone can spin up a pool on PumpSwap. This means you can see fake pools, honeypot tokens, or pools with tiny liquidity designed to trap buyers.
• Mint authority. Some token creators retain the ability to mint additional tokens after graduation. They can inflate the supply and dump on buyers. The bonding curve does not allow this.

How the data differs between exchanges

PumpFunData serves both exchanges as separate datasets. The pump_fun exchange has bonding curve data and pump_amm has AMM data. The schema is mostly the same but there are important differences.

How to spot risky tokens in the data

You can use PumpFunData to build your own safety checks. Here are a few red flags you can detect programmatically.

import pandas as pd

df = pd.read_parquet("pump_amm_2026-04-15_12.parquet")

# Flag 1: tokens with freeze authority enabled
frozen_tokens = df[df["can_be_frozen"] == True]["token_mint"].unique()
print(f"Tokens with freeze authority: {len(frozen_tokens)}")

# Flag 2: liquidity withdrawals (potential rug pulls)
withdrawals = df[
    (df["event_type"] == "liquidity") & (df["action"] == "withdraw")
]
print(f"Liquidity withdrawals this hour: {len(withdrawals)}")

# Find the biggest withdrawals by SOL amount
if len(withdrawals) > 0:
    top_withdrawals = (
        withdrawals
        .sort_values("lamports_amount", ascending=False)
        .head(5)[["token_mint", "user_wallet", "lamports_amount"]]
    )
    top_withdrawals["sol_amount"] = top_withdrawals["lamports_amount"] / 1e9
    print(top_withdrawals[["token_mint", "user_wallet", "sol_amount"]])

Track a token across both exchanges

The most interesting analysis comes from following a token through its entire lifecycle. It starts on the bonding curve, graduates, and then trades on the AMM. You can join the two datasets on token_mint to get the full picture.

import pandas as pd
import glob

# Load both exchanges for the same day
pf_files = sorted(glob.glob("data/pump_fun/2026-04-15/*.parquet"))
amm_files = sorted(glob.glob("data/pump_amm/2026-04-15/*.parquet"))

pf = pd.concat([pd.read_parquet(f) for f in pf_files], ignore_index=True)
amm = pd.concat([pd.read_parquet(f) for f in amm_files], ignore_index=True)

# Find tokens that graduated
graduated_mints = pf[pf["event_type"] == "bonding_complete"]["token_mint"].unique()

# Pick one and get its full history
mint = graduated_mints[0]
bc_swaps = pf[(pf["token_mint"] == mint) & (pf["event_type"] == "swap")]
amm_swaps = amm[(amm["token_mint"] == mint) & (amm["event_type"] == "swap")]

# Bonding curve price (virtual reserves)
bc_swaps = bc_swaps.copy()
bc_swaps["price_sol"] = (
    bc_swaps["virtual_lamports_reserve"]
    / bc_swaps["virtual_token_reserve"]
    / 1e9
)

# AMM price (real reserves)
amm_swaps = amm_swaps.copy()
amm_swaps["price_sol"] = (
    amm_swaps["real_lamports_reserve"]
    / amm_swaps["real_token_reserve"]
    / 1e9
)

print(f"Bonding curve swaps: {len(bc_swaps)}")
print(f"AMM swaps: {len(amm_swaps)}")
print(f"Last BC price: {bc_swaps.iloc[-1]['price_sol']:.10f} SOL")
print(f"First AMM price: {amm_swaps.iloc[0]['price_sol']:.10f} SOL")

# Check safety flags
frozen = pf[(pf["token_mint"] == mint)]["can_be_frozen"].any()
print(f"Freeze authority: {frozen}")

Which exchange should you focus on

It depends on what you are building. If you are looking for safer trading opportunities with less rug pull risk, the bonding curve data in pump_fun is where you want to focus. The mechanics are predictable and the contract protects you from the worst outcomes.

If you are building analytics, risk detection, or monitoring tools, the AMM data in pump_amm is valuable because that is where the interesting (and dangerous) activity happens. Liquidity events, freeze authority flags, and pool creator addresses give you the signals you need to flag risky tokens before they blow up.

For the most complete picture, use both. Track tokens from creation through graduation and into AMM trading. The data tells you everything that happened on-chain.