· Checked November 18, 2026

Where a new Pump.fun token shows up first, and where it shows up later

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#

  1. 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.
  2. Execution-based streams at processed commitment. Geyser-style transaction updates arrive as soon as a node has executed the transaction, while logsSubscribe notifications arrive only once the whole block reaches the commitment you request, which defaults to finalized; both add the outcome and the logs.
  3. Confirmed RPC reads. getTransaction or getBlock at a confirmed commitment returns the settled result once the block is confirmed.
  4. 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 needStart withThen
The earliest signal, and you can confirm laterRaw shredsConfirm by signature
Only successful launches, with logsAn execution-based stream at confirmed commitmentNothing else, or confirm by signature if you subscribe at processed
A simple setup with standard toolslogsSubscribe on the programFetch the transaction if you need arguments
A list of tokens for displayAn indexer APIRefresh 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#

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.