Dev.to Security 🔐 Cybersecurity 👁 0 📖 6 min read

How to find the dev wallet of a pump.fun token (and verify it yourself)

"Who is the dev?" is usually three different questions wearing one coat. What people mean How it is proved creator — the wallet that launched the mint the fee payer of the transaction containing Create funde

"Who is the dev?" is usually three different questions wearing one coat.

What people mean How it is proved
creator — the wallet that launched the mint the fee payer of the transaction containing Create
funder — the wallet that paid for the creator to exist a SOL transfer into the creator, usually minutes before launch
first buyer — whoever bought first nothing about ownership; this is not the dev

Only the first two are provable from chain data. The third is a trader, and a lot of "dev wallet exposed" posts are just that: the first buyer, presented as the creator.

This post is about finding the first one, honestly, and checking it yourself.

The short answer

For a mint, the creator is the fee payer of the transaction that contains the Create instruction. On pump.fun that transaction is the mint's first transaction, so the naive method is:

  1. get the mint's signatures
  2. take the oldest one
  3. read its fee payer

That works on a token that launched an hour ago and has forty transactions. It falls apart on anything people actually care about, and the reason is worth understanding before you trust someone else's answer.

One caveat: the fee payer is the creator unless a third party paid the fee on their behalf, which launchpad tooling can do. That is rare, and it is exactly why every edge keeps its signature — a claim you cannot check is not evidence.

Why walking a token backwards fails

Signatures come back newest-first. Reaching the creation means paging through the mint's entire history, and a pump.fun mint that has been trading for a few hours can have tens of thousands of transactions.

I tried this on one mint that launched the previous evening. Forty pages of getSignaturesForAddress, 40,000 signatures, and the oldest transaction I reached was still an ordinary trade. The creation was further back than the page limit I was willing to spend. On a public RPC at 1–11 seconds per getTransaction, finishing that walk is minutes of waiting, and the mint keeps growing while you do it.

So the direction is wrong. Do not walk from the mint forward through its life. Walk from the candidate wallet backwards through its own actions. A wallet has hundreds of transactions, not tens of thousands, and the events you care about are recent.

The stronger signal: fee collection

pump.fun lets a mint's creator collect the creator fee. The instruction has appeared under three names over time:

SweepCreatorFee
CollectCreatorFee
CollectCreatorFeeV2

All three mean the same thing, and the important property is this: only the mint's creator can collect its fee. It is enforced by the program, not by convention.

That makes a fee collection stronger evidence than a creation:

  • a creation says this wallet paid to launch a mint
  • a fee collection says this wallet is the mint's creator

Anyone can pay to create a token. Being the creator of one is a fact with an owner.

It also fixes a blind spot. If you only count creations, a creator whose earlier launches fall outside your scan window looks inactive. Their sweeps still show up, because fees get collected repeatedly.

In the scan above, 60 mints had both events inside the same 250-transaction window. Median gap from creation to first fee collection: 3 minutes, and the slowest of the 60 was under an hour. That sample is biased toward fast sweeps — a mint that was only swept a day later would not have both events inside the window — but the bias runs in the useful direction: the sweep you are looking for sits near the top of the mint's history, not at the bottom.

Check it yourself in about a minute

Browser, no install

https://tdkrhuang.github.io/solana-launch-forensics/demo/

Paste a wallet. You get one node per mint around it: blue = created only, green = fee swept only, purple = both. Click a mint and the two signatures appear, linked to Solscan.

A link with ?wallet=<address> runs that scan on load, so you can hand someone the exact view instead of describing it.

Command line

pip install solana-launch-forensics
launchforensics cluster 6N7e1YN4JmgtMYcGXUCyBXfdpqxcqcZME7DXHHh8NiPc --limit 250

Output, trimmed:

wallet      6N7e1YN4JmgtMYcGXUCyBXfdpqxcqcZME7DXHHh8NiPc
scanned     250 transactions
evidence    created 76, funded 3, swept 81
clusters    1  (minimum 2 mints)

cluster 1: 97 mints, 2 wallets
  links      created 76, funded 3, swept 81
  window     2026-11-22 04:10:46 -> 2026-11-22 11:01:48 (411m 2s)
  wallets
    - 6N7e1YN4JmgtMYcGXUCyBXfdpqxcqcZME7DXHHh8NiPc
    - HZWTjHs39weFS2VmQVqK8NxUarzh9T5WeRfXmAu2GQmT
  evidence
    created  6N7e1YN4Jm..NiPc -> AvTvw2jHbG..pump  55HyuSDG1WMb..KPJp
    swept    6N7e1YN4Jm..NiPc -> 3qhnFKn3hM..pump  56FQX2pANxwc..D8vd

Two wallets in one cluster means a funding transfer connects them: one paid for the other, and both create and collect. The graph draws that as an orange edge between the two centre nodes.

Check one transaction by hand

launchforensics tx <signature>

It prints the fee payer, the pump.fun instructions the parser attributed, and the mints the transaction touched.

Attribution is where this goes wrong. Program log: lines do not carry a program id, so a parser that matches instruction names without walking the invoke stack will read the token program's InitializeMint2 as a launch. Two events, two programs, one careless grep.

One transaction, many mints

A sweep is not one transaction per mint. A real one:

signature   dZKUzyittR9cfYD2Gnuvrht8nuNq552vF6ZnBxTT5jjZwWe4S7oNvfu72zTWxYyoV5dFe3WsKvQPBN76bi5B9se
time        2026-10-25 14:03:50 UTC
fee payer   3KBUuqsAirs4KpvFj91hTrGm5KGPsh5eLud45MWDqz7E
pump ops    SweepCreatorFee x5, CollectCreatorFeeV2
creates     0
mints       5 referenced

Five mints' fees in one transaction. Count transactions and you undercount the mints by a factor of five; that is why the tool emits one edge per mint and the cluster size is a mint count, not a transaction count.

Three checks before you trust a "dev wallet"

1. Is it the creator, or the first buyer?
Ask for the creation transaction. If the answer is a buy, it is not the creator.

2. Does it collect the mint's fees?
One CollectCreatorFee beats any number of screenshots. If the wallet never collected, the claim may still be true, but it is now a claim about a creation, and you should read the creation transaction yourself.

3. Who funded it, and when?
A creator wallet funded five minutes before launch, with one prior transaction, is a burner. That does not make the launch a scam, but it does mean the interesting wallet is one hop back. The funding transfer has a signature too.

Run those three and you will know more than most threads claiming to have "found the dev".

What this cannot tell you

  • Who sold. Selling is a swap from a token account. The cluster maps creation and control, not disposal.
  • Intent. A wallet can create 108 tokens in nine hours and be a launchpad operator. The data does not grade motive.
  • Whether the funder is a person. Exchanges and faucets fund thousands of wallets. A shared funder is a lead, not proof.
  • The whole history. A scan covers the last N transactions. Every honest output should say how many, which is why the tool prints the window.

The correct summary of a cluster is narrow: these mints share an owner, and here are the signatures. Anything past that is an inference and should be labelled as one.

When it is worth paying someone

Checking one wallet takes a minute and the tool is MIT, so start there.

A written report is for the case where the answer has to survive someone else reading it: creator and funding chain with each level signed, where the SOL went, authorities, remaining position, and a reproducibility appendix. That is a document you can attach to a dispute instead of a thread you have to defend line by line.

If a number in this post does not match what you see on chain, open an issue. The signatures are there precisely so the claim can be checked, including by me being wrong.

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.