Canonical: https://solanashreds.xyz/compare/new-token-data-sources

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

How to detect new Pump.fun tokens: each data source in the order it can see a create transaction, with its failure modes and no invented times.

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](https://solanashreds.xyz/docs/programs/pump-fun) 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](https://solanashreds.xyz/blog/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](https://solanashreds.xyz/learn/pump-fun-bonding-curve), follow [a launch transaction byte by byte](https://solanashreds.xyz/blog/a-pump-fun-launch-byte-by-byte), and add [a program filter](https://solanashreds.xyz/docs/decode/filter-by-program) so your decoder ignores everything else. When you are ready for live packets, the [pricing page](https://solanashreds.xyz/pricing) lists both plans.

Token launches are one case of a broader signal covered in [spotting new accounts](https://solanashreds.xyz/blog/spotting-new-accounts).
