What's the difference between Pump.fun and PumpSwap?

Pump.fun is the bonding-curve launchpad. Every new token starts on a pre-defined curve where price increases as supply is bought. Once the curve fills (~$69k market cap historically), the token graduates: Pump.fun emits a migrate instruction and a matching PumpSwap pool is created with the bonded liquidity. PumpSwap is the AMM where post-graduation trading lives. Two distinct programs, two IDLs. Most production analytics treat them as one combined memecoin pipeline.

Is the PumpSwap API free or pay-per-message?

There is no official PumpSwap API. Third parties price it three ways. PumpPortal charges per WebSocket message (0.01 SOL per 10,000 messages, which is easy to overspend on a busy memecoin day). Bitquery prices by query/dataset on its GraphQL platform. We charge flat: $49/month Pro (2 streams), $199/month Ultra (20 streams). No per-event surcharge. Flat-rate is the right pick when volume is unpredictable.

How do I detect Pump.fun to PumpSwap migrations in real time?

Subscribe to both program IDs in one gRPC stream and watch for transactions that include a Pump.fun migrate instruction. Many migrations are atomic: the same transaction contains the migrate followed by the PumpSwap create_pool, so one tx hash gives you both legs. We surface this as a typed Migration event with the token mint, the bonded SOL amount, and the new PumpSwap pool address.

How do I subscribe to PumpSwap trades via WebSocket or gRPC?

For production, gRPC. Subscribe with a transactions filter on pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA, set commitment to processed, and the buy / sell instructions land within ~13ms of slot processing. For prototypes, WebSocket logsSubscribe on the same program ID returns raw logs you parse client-side. Production volume is high enough that WebSocket starts choking. gRPC is the default.

Does PumpSwap have an official API?

No. Pump.fun publishes an SDK (@pump-fun/pump-swap-sdk) for transaction construction but does not run a hosted real-time data API. Every production feed is operated by a third party (PumpPortal, Bitquery, Shyft, us) by indexing the on-chain program directly.

What's the fastest way to snipe a new PumpSwap pool?

Subscribe to the Pump.fun program with a discriminator filter on the migrate instruction. Decode it to grab the token mint and the new PumpSwap pool address. Submit a buy on the freshly created pool in the next slot via Jito bundle. Our parsed stream emits the migration as a typed event, so the bot doesn't pay the IDL decoding tax per transaction. Sub-50ms p99 from migrate-landing to bot-decision is achievable on a tight loop.

How does NoLimitNodes compare to PumpPortal and Bitquery for PumpSwap data?

PumpPortal: per-message WebSocket. Predictable when traffic is, expensive at memecoin peaks. Bitquery: GraphQL with rich historical queries. Strongest for analytics, weaker for sub-second decisioning. We ship parsed gRPC with flat pricing, both Pump.fun and PumpSwap in one feed, and the 10x price guarantee. Pick by job: bots / snipers / market making goes to us, historical analysis / dashboards goes to Bitquery.

Enhanced Stream

The PumpSwap API: real-time, parsed Solana memecoin trade and pool data

PumpSwap is where Pump.fun tokens land after they graduate, and at memecoin peaks it does five to fifteen million trade instructions a day. The current API market is two camps. PumpPortal sells per-message WebSocket subscriptions, which is predictable until a token rips and the bill multiplies. Bitquery sells GraphQL access, which is excellent for historical work but laggy for anything trade-adjacent. We do the third thing: parsed gRPC covering every PumpSwap buy, sell, and pool creation in one feed, plus the Pump.fun migrate that triggers each graduation. Both legs in the same transaction, both decoded, 13ms p50. Flat, no per-event meter.

Bonding-curve + AMMMigration trackingSub-50ms latencyFlat flat pricingNo per-message fees

On-chain programs

PumpSwap AMMpAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA, AMM program where bonding-curve graduates settle (mainnet AND devnet)
Pump.fun bonding curve6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P, Pump.fun launchpad, emits the migrate instruction that hands tokens off to PumpSwap

Try it live: PumpSwap streams

decoded solana events over grpc · click Run to see live data

2 streamslive

PumpSwap AMM

PumpSwap AMM swaps with decoded amounts and mints

1grpcurl -H "x-api-key: YOUR_API_KEY" \
2  -d '{"topic":"prod.mat.solana.program.swaps.pumpswap","format":"JSON"}' \
3  stream-1.nln.clr3.org:443 nln.stream.v1.StreamService/Subscribe

Live Output

See real data

Click Run to stream 5 live PumpSwap AMM messages

Pro: 2 streams $49/mo · Ultra: 20 streams $199/mo · pre-parsed, zero infra

The PumpSwap events you can stream

every decoded instruction across the AMM and bonding-curve programs

Event	Type	Description	Frequency	Latency
buy	instruction	PumpSwap AMM buy. Decoded with token mint, base / quote amounts, price, and tx fee.	Very high	13ms
sell	instruction	PumpSwap AMM sell. Same shape as buy with sign reversed; surfaces exit liquidity per memecoin.	Very high	13ms
create_pool	instruction	New PumpSwap pool initialization. Includes both mints and the initial reserves seeded by the migration.	Medium	13ms
deposit	instruction	LP add-liquidity into PumpSwap. Useful for tracking which traders are providing post-graduation liquidity.	Medium	13ms
withdraw	instruction	LP remove-liquidity. Pairs with deposit to compute realized fees per LP wallet.	Medium	13ms
migrate	instruction	Pump.fun → PumpSwap migration, emitted on the Pump.fun program when a token bonds. Triggers the create_pool that follows.	Medium	13ms
set_pool_authority	instruction	Pool authority transfer. Rare but useful for forensics and pool ownership audits.	Low	13ms
collect_protocol_fees	instruction	Protocol fee withdrawal, surfaces protocol-level revenue events.	Low	13ms

PumpSwap streaming performance

last reviewed 2026-04-28

Trade latency

13ms

p50 from slot landing to your socket; PumpSwap buy/sell over gRPC

Verified 2026-04-28

Daily PumpSwap trades

5-15M

Buy + sell instructions per day at peak memecoin cycles

Migrations per day

50-500

Pump.fun graduations into PumpSwap, depending on cycle

Stream uptime SLO

99.95%

Pro and Ultra plans, monthly rolling

PumpSwap vs the Pump.fun bonding curve

The Pump.fun memecoin pipeline has two stages and two on-chain programs. Stage one is the bonding curve: a deterministic price function where each buy moves the price up and each sell moves it down. The curve runs on the Pump.fun program at 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. Every new memecoin starts here.

Stage two is PumpSwap: pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA, an AMM where graduated tokens settle once the bonding curve fills. When the curve completes, Pump.fun emits a migrate instruction; a matching PumpSwap pool gets initialized with the bonded SOL and tokens; from that point the token trades like any other pair.

For a sniper, the boundary between the two stages is the most interesting moment in a memecoin's life. Graduations historically trigger a price re-rating as liquidity becomes symmetric. For an analytics platform, the right mental model is to treat Pump.fun and PumpSwap as one pipeline, not two unrelated streams.

PumpSwap on chain: program ID, instructions, the migration event

PumpSwap exposes seven principal instructions: buy, sell, create_pool, deposit, withdraw, set_pool_authority, and collect_protocol_fees. Buy and sell carry the trader, mint, base/quote amounts, and a price snapshot. create_pool is what fires after a Pump.fun graduation.

The migrate instruction itself lives on the Pump.fun program, not on PumpSwap, because the bonding curve is what initiates the transfer. A typical graduation transaction contains the migrate instruction followed by the PumpSwap create_pool in the same transaction. Detecting a graduation in real time therefore means subscribing to both program IDs and joining instructions by transaction signature.

Our parsed stream collapses the two-program join into one typed Migration event per graduation: token mint, bonded SOL amount, new PumpSwap pool address, and the bonding-curve final state. Your downstream code handles one event shape instead of two.

PumpPortal, Bitquery, NoLimitNodes: pricing, latency, parsed depth

The PumpSwap data market has three distinct positions. Each one fits a different job. The difference between them shows up most sharply in cost predictability.

Provider	Pricing model	Strength	Weakness
PumpPortal	Per-message WebSocket	Easy WS API, low minimum	Cost spikes on memecoin days
Bitquery	Per-query GraphQL	Deep historical, JOINed views	GraphQL latency vs gRPC
NoLimitNodes	Flat	Sub-50ms gRPC, both programs in one feed	No GraphQL surface (yet)

Pick based on whether your workload is reactive (bots, MEV, market making, which goes to us) or analytical (dashboards, leaderboards, research, which goes to Bitquery). Many teams use both. NLN for live, Bitquery for backfill. The two are complementary more than competitive.

Common PumpSwap API use cases

Sniper bots

Filter on the Pump.fun migrate + PumpSwap create_pool pair to catch graduations the moment they hit. The migration moment is historically a re-rating event. Bots that detect and act on it inside the same Jito bundle window capture meaningful edge.

Copy trading

Subscribe to the buy / sell stream filtered by trader wallet to replicate trades. Sub-50ms parsing means your follower trade lands in the slot after the leader's. Close enough to keep most of the alpha on volatile memecoin pairs.

Analytics & leaderboards

Aggregate buys and sells per token to build top-trader and top-token leaderboards. Combine with the Pump.fun bonding-curve stream for full lifecycle metrics: first buyer, top holder decay, post-graduation retention.

MEV & arb

PumpSwap pairs occasionally arb against Raydium CPMM, Meteora DLMM, and Jupiter routes during high-volume bursts. The live trade stream lets arb engines compute post-trade pool state inside the same slot.

Detecting Pump.fun → PumpSwap migrations the moment they happen

Migration detection is the highest-value moment in the Pump.fun → PumpSwap pipeline. The on-chain signal is precise. A single transaction contains a Pump.fun migrate instruction followed by a PumpSwap create_pool in the same instruction list. The migrate carries the token mint and the bonded SOL amount; create_pool surfaces the new AMM pool address.

To catch it live, subscribe to both program IDs in a single Yellowstone gRPC subscription using accountInclude with both addresses. When a transaction touches both programs in the same slot, route it through a migration handler. Our parsed stream does the join for you and emits a typed Migration event. Simplest possible interface for a sniper bot.

For backfill or post-hoc analytics, see the historical Pump.fun data product, which exposes every graduation since the program launched. The companion real-time Pump.fun stream covers the bonding-curve side of the lifecycle.

Frequently asked questions

The PumpSwap AMM program lives at pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA on Solana mainnet, the same address is used on devnet. The companion Pump.fun bonding-curve program is 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P. Subscribing to both program IDs gives you the full memecoin lifecycle: launch on Pump.fun, trades on the bonding curve, migration when the curve completes, then trades on PumpSwap.