To detect new Pump.fun tokens as early as the network allows, read the create instruction from raw shreds, then confirm it later. Execution-based streams and log subscriptions see the same launch only after the transaction runs, but they tell you whether it succeeded. Indexer APIs and the Pump.fun site come last, once the token has been processed and stored.
The order sources can see a create#
- Raw shreds. The signed create transaction sits in the block's entries before the leader has finished the block. You can match the program and the instruction, but you do not yet know whether it will succeed.
- Execution-based streams at processed commitment. Geyser-style transaction updates arrive as soon as a node has executed the transaction, while
logsSubscribenotifications arrive only once the whole block reaches the commitment you request, which defaults to finalized; both add the outcome and the logs. - Confirmed RPC reads.
getTransactionorgetBlockat a confirmed commitment returns the settled result once the block is confirmed. - Indexer APIs and the Pump.fun front end. These show the token after their own processing and storage, in their own schema.
Positions describe sequence only. How far apart they are depends on your location and providers, so measure on your own server rather than trust a figure from anywhere else.
Source by source#
Raw shreds#
The Pump.fun program (6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P, E4 tech facts I-19) publishes an official IDL with two creation instructions, create and create_v2, each with its own 8-byte discriminator. A decoder watches for top-level instructions to that program whose data starts with either discriminator, then reads the name, symbol, URI and creator arguments and the mint and bonding curve accounts; a create made by another program through a CPI is an inner instruction and does not appear in shreds (E4 tech facts X-02). The Pump.fun create recipe builds exactly this.
Caveat: entries hold signed transactions with no execution result (E4 tech facts X-01), so a create you see here can still fail.
Execution-based streams#
A Geyser-style update pairs the transaction with its execution metadata, so you see success or failure and the logs in one message. The program's CreateEvent is an execution output: Anchor events are written either as log data or as a self-CPI, and neither appears in raw transactions (E4 tech facts X-03).
Caveat: you depend on the provider's filters, schema and connection limits.
logsSubscribe#
The standard RPC WebSocket method. Subscribe with a mentions filter on the program address; the docs note that mentions accepts exactly one address. Each notification gives the signature, an error value and the log lines, but not the instruction bytes, so you parse logs or fetch the transaction afterwards.
Caveat: log output can be truncated for long transactions, and parsing log text is more fragile than decoding instruction data.
Confirmed RPC reads#
Polling or fetching by signature at a confirmed commitment gives you the settled transaction with its full metadata. It is the right place to confirm what you saw earlier, rarely the right place to discover it.
Indexer APIs and the front end#
Convenient and already decoded, but they reflect someone else's pipeline and schema. Use them for enrichment and display, not for the first signal.
False positives: creates that never stick#
Anything you detect before execution is provisional. A create can land in a block, fail and still cost its sender the fee, or disappear when its slot is skipped; the certificates that finalize blocks under Alpenglow are not in the shred stream (E4 tech facts X-04). Mark early detections as pending, and confirm each one by signature before you treat the token as real. Landed but failed covers the failure case in detail.
Picking a source#
| You need | Start with | Then |
|---|---|---|
| The earliest signal, and you can confirm later | Raw shreds | Confirm by signature |
| Only successful launches, with logs | An execution-based stream at confirmed commitment | Nothing else, or confirm by signature if you subscribe at processed |
| A simple setup with standard tools | logsSubscribe on the program | Fetch the transaction if you need arguments |
| A list of tokens for display | An indexer API | Refresh periodically |
Questions about launch detection#
Which instruction marks a new Pump.fun token?#
The official IDL lists two: create and create_v2. Match both discriminators, because a decoder that knows only one will miss launches made with the other.
Can I see whether a launch succeeded from shreds?#
No. Shreds carry the signed transaction only. Success or failure comes from execution, so confirm with RPC or an execution-based stream.
Why not just parse logs?#
Logs need execution and arrive later than raw transactions, they can be truncated, and their text format is easier to break than the instruction layout in the IDL.
Does the IDL ever change?#
Yes. Programs add instructions and arguments over time, which is why this page names the IDL commit it was checked against. Recheck before you rely on an older decoder.
When shreds are not worth it for launches#
If you only list tokens for people to browse, or you act only after a launch has succeeded, an execution-based stream or plain logsSubscribe is simpler and good enough. Raw shreds pay off when acting on the create itself is the point, and when you are prepared to handle the creates that later fail.
Build it#
Read how the bonding curve works, follow a launch transaction byte by byte, and add a program filter so your decoder ignores everything else. When you are ready for live packets, the pricing page lists both plans.
Token launches are one case of a broader signal covered in spotting new accounts.
Sources#
- Pump.fun official IDL, idl/pump.json (program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P; create and create_v2), commit 639b87f (checked 2026-11-18)
- Agave source: the Entry struct (checked 2026-11-18)
- solana-transaction-status crate: TransactionStatusMeta (checked 2026-11-18)
- Solana RPC reference for the logsSubscribe WebSocket method (checked 2026-11-18)
- Yellowstone gRPC proto: transaction updates carry TransactionStatusMeta (checked 2026-11-18)
- Anchor source: event emission through logs and emit_cpi (checked 2026-11-18)
- SIMD-0326 Alpenglow: certificates and skipped slots (checked 2026-11-18)
Raw shreds on your own server
Ultra Low Latency Shreds is $200 and Standard Shreds is $100. You pay in crypto, tell us which IPv4 address and UDP port should receive the stream, and we wire it up by hand.