The pump.fun API in 2026: what exists, what doesn't, and how to use it

If you searched for "pump.fun API", here is the short answer: pump.fun does not publish a public developer API. There is no documentation portal, no API key you can request from pump.fun, and no promise that anything stays the same next month. Its website and mobile app read from a handful of private hosts, and that is what every "pump.fun API" on GitHub is built on.

This guide covers what those hosts are and which pump.fun data exists. It compares the ways developers get that data and walks you from an API key to working code in curl, Python and JavaScript. We run pumpfomo, a read-only API for pump.fun and fomo.family data, so we'll show our own endpoints. We'll also say where something else fits better.

#Is there an official pump.fun API?

No. pump.fun ships apps, not a developer platform. What exists is the backend its own apps talk to, spread over several hosts:

• frontend-api-v3.pump.fun: profiles, follows, coins, search and callouts.
• swap-api.pump.fun: trades, candles and trading stats.
• A few more (profile-api, advanced-indexer and others) for PnL, portfolios and indexing.

You can call some of these from a script, and that is where community projects start. Before you build on them, know what you are signing up for. We learned these points by capturing the traffic of pump.fun's own apps:

• There are no docs or versions. Fields are added, renamed and removed without notice. One answer can mix snake_case and camelCase.
• Some routes need a session. pump.fun signs its users in with a JWT, sent as an auth_token cookie or an Authorization: Bearer header. Profile and coin reads mostly work without it. Anything about "me" and several stats routes do not.
• Cloudflare sits in front. It challenges clients that don't look like pump.fun's own apps, so a plain curl from a server often gets an HTML challenge instead of JSON.
• Rate limits are per minute and per route. frontend-api-v3 and swap-api send x-ratelimit-limit, -remaining and -reset headers, and the reset values point to a 60-second window. Limits we saw range from 30 to 60 requests a minute on common routes.

None of this is a problem for a weekend script. It is a problem for a product that has to keep working, which is why most teams either use a data provider or maintain a client full time.

#What pump.fun data exists

pump.fun is two things at once: a token launchpad with an exchange, and a social network of traders. The data splits the same way.

The table has 12 rows; the reference lists 53 pump.fun endpoints in total, every one with a real captured answer.

#On-chain data vs. pump.fun's social layer

This is the decision that matters most, so it is worth being precise about.

On-chain data is anything you can read from Solana or an EVM chain: token launches, bonding-curve trades, graduations to an AMM, prices, holders, transfers. You can index it yourself with an RPC node or a Geyser plugin. Several companies sell it ready-made: Bitquery, Codex, Solana Tracker, Moralis and Helius all cover pump.fun tokens well. If your product is a price chart, a launch sniper or a holder scanner, one of them (or your own indexer) is the right tool.

The social layer lives only in pump.fun's database: usernames and avatars, who follows whom, callouts and the theses written on them, the PnL leaderboard, competitions, trading streaks, creator-fee shares. No block explorer will tell you that a wallet belongs to a trader with 40,000 followers, or that their last six calls hit 2x half the time. If your product is about people (tracking traders, ranking callers, building a social feed, copy trading), you need this layer, and it only comes from pump.fun's own backend.

Most real products need both: on-chain trades and prices, joined to the people behind the wallets. That join is what pumpfomo is built around.

#Your options, compared

pumpfomo is read-only. It does not place trades or sign anything. If you want to buy and sell, you need a trading API or your own transactions against pump.fun's programs; pumpfomo gives you the data to decide what to trade.

#How to get a pump.fun API key

pump.fun itself has no keys to hand out. With pumpfomo, it takes about a minute:

1. Go to pumpfomo.com/signin and sign in with a wallet (Phantom or any EVM wallet) or with Telegram. No email or card.
2. In the dashboard, open Keys and create one. It starts with pf_live_ and is shown once, so copy it somewhere safe.
3. The Free plan gives you 10,000 credits a month at 2 requests a second. Most pump.fun reads cost 1 or 2 credits, so that is enough to build and test.

Give each key only the scopes it needs (read:pump, read:fomo, read:wallet, stream). You can limit a key to your server's IP ranges. Keep keys on the server: a key shipped in a browser bundle is a key anyone can copy.

#Your first pump.fun API calls

Every request sends the key in Authorization: Bearer (or X-API-Key). The base URL is https://api.pumpfomo.com.

#curl: a trader's PnL

curl -s "https://api.pumpfomo.com/v1/pump/users/4UrFSCrGxgoCtCUBAEZq7ZmPK3Pczkxx7PwYnkBMi1KR/pnl?period=1w" \
  -H "Authorization: Bearer $PUMPFOMO_KEY"

The answer wraps pump.fun's data in data, and meta says where it came from and how fresh it is:

{
  "data": {
    "wallet": "4UrFSCrGxgoCtCUBAEZq7ZmPK3Pczkxx7PwYnkBMi1KR",
    "pnl": { "sol": 3215.28, "usd": 306995.28 },
    "realizedPnl": { "sol": 21.68, "usd": 5362.14 },
    "unrealizedPnl": { "sol": 3193.6, "usd": 299883.44 },
    "totalBuySpend": { "sol": 21.69, "usd": 51396.63 },
    "tokenCount": 121,
    "holdings": [{ "chain": "solana", "mint": "6GmAFSYs…", "valueUsd": 1265928.37 }]
  },
  "meta": { "source": "pump.fun", "cache": "live", "fetchedAt": "2026-10-25T23:10:31Z" }
}

That is a real answer from the week it was captured, trimmed. Notice how much of the PnL is unrealized: one large open bag. That matters if you rank traders by PnL, and we come back to it in the copy-trading guide.

#Python: every trade of a wallet

Trades come 100 a page, newest first. Pass the last page's nextCursor to get the next one:

import os
import requests

BASE = "https://api.pumpfomo.com"
HEADERS = {"Authorization": f"Bearer {os.environ['PUMPFOMO_KEY']}"}

def trades(wallet, pages=5):
    cursor = None
    for _ in range(pages):
        params = {"types": "trades"}
        if cursor:
            params["cursor"] = cursor
        r = requests.get(f"{BASE}/v1/pump/users/{wallet}/trades",
                         headers=HEADERS, params=params, timeout=15)
        r.raise_for_status()
        page = r.json()["data"]
        yield from page["trades"]
        cursor = page.get("nextCursor")
        if not cursor:
            break

for t in trades("4UrFSCrGxgoCtCUBAEZq7ZmPK3Pczkxx7PwYnkBMi1KR"):
    side = "BUY " if t["isBuy"] else "SELL"
    print(t["timestamp"], side, t["mint"], round(t["amountUsd"], 2))

Each trade has tx, isBuy, timestamp, amountUsd, amountSol, baseAmount, priceUsd, mint and chainId. A page costs 2 credits whatever its size.

#JavaScript: a coin and its last hour

const BASE = "https://api.pumpfomo.com"
const headers = { Authorization: `Bearer ${process.env.PUMPFOMO_KEY}` }

async function get(path) {
  const res = await fetch(BASE + path, { headers })
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`)
  return (await res.json()).data
}

const mint = "6GmAFSYs4gk3FDao5FzzySQpPZaWsa4rUJHacpMpUNgx"
const [coin, activity] = await Promise.all([
  get(`/v1/pump/coins/${mint}`),
  get(`/v1/pump/coins/${mint}/market-activity`),
])
const hour = activity["1h"]
console.log(coin.name, coin.symbol, Math.round(coin.usd_market_cap))
console.log(`1h: ${hour.numTxs} trades, $${Math.round(hour.volumeUSD)} volume,`,
  `${hour.numBuyers} buyers / ${hour.numSellers} sellers, ${hour.priceChangePercent.toFixed(1)}%`)

Market activity gives trades, volume, buyers, sellers and price change over 5 minutes, 1 hour, 6 hours and 24 hours. For up to 50 coins at once there is a batch version.

#pump.fun on EVM chains

pump.fun is no longer Solana-only. Coins also trade on Base, BNB Chain, Ethereum, Robinhood Chain, Monad, Arc and X Layer, and the live stream also carries MegaETH, Polygon, Ink and HyperEVM. For an EVM coin, the mint is a 0x address, and pump.fun needs to know the chain. Pass it as an EVM chain id:

curl -s "https://api.pumpfomo.com/v1/pump/coins/0x2E8c31162b855A2ffa90F6F8634643Ad6F111e18/trades?chain=4663" \
  -H "Authorization: Bearer $PUMPFOMO_KEY"

The ids are 8453 (Base), 56 (BNB Chain), 1 (Ethereum), 4663 (Robinhood Chain), 143 (Monad), 5042 (Arc) and 196 (X Layer). Wallet-level routes like balances, portfolio and PnL already span every chain pump.fun knows, so they don't need it.

#Rate limits, credits and errors

Every answer carries what it cost and what is left:

• X-Credits-Cost and X-Credits-Remaining: the price of this call and your balance after it.
• RateLimit-Limit, RateLimit-Remaining and RateLimit-Reset: your key's bucket. A 429 comes with Retry-After.
• X-Request-Id: quote it if you ever need support.

Prices are in credits:

Plans run from Free (10,000 credits a month) through Starter at $49 for 100,000 credits, up to Scale at $1,249 for 7,500,000. On Starter a credit costs about $0.0005, so reading a pump.fun profile costs a twentieth of a cent. You pay in USDC on Solana, Base, BNB Chain or Ethereum. The full list is on the pricing section.

#Things that trip people up

• Numbers as strings. Some pump.fun fields, like a coin's market_cap in the new-coin feed, are decimal strings, so parse them yourself. Trade tapes give raw amounts with decimals next to them.
• Two kinds of time. Some routes send ISO dates (2026-10-25T08:19:15.000Z), others Unix milliseconds (blockTimeMs). Check each field.
• Users vs. wallets. A pump.fun user has a UUID and one or more wallets. Routes marked {id} take either; routes marked {wallet} need an address. When you're not sure what an address is, /v1/pump/resolve tells you whether it is a user, a coin or neither.
• Lists skip NSFW coins. pump.fun's own lists hide coins flagged NSFW. So does ours.
• EVM addresses come lower-case in streams and are matched case-insensitively everywhere.

#Frequently asked questions

#Does pump.fun have an official API?

No. pump.fun has no public, documented API and doesn't issue API keys. Its apps use private hosts like frontend-api-v3.pump.fun, which change without notice. Third-party APIs like pumpfomo give you a stable, documented way to read the same data.

#Is there a free pump.fun API?

pumpfomo's Free plan includes 10,000 credits a month, enough for roughly 5,000 to 10,000 pump.fun reads, with no card needed. Some on-chain providers also have free tiers for launches and prices, but they don't include pump.fun's social data.

#How do I get a pump.fun API key?

pump.fun doesn't issue keys. With pumpfomo you sign in with a wallet or Telegram, create a key in the dashboard and start with the Free plan. Keys look like pf_live_….

#Can I trade on pump.fun through this API?

No. pumpfomo is read-only: it never places orders or signs transactions. To trade, send transactions to pump.fun's programs yourself or use a trading API, and use pumpfomo for the data that decides what to trade.

#Does the API cover pump.fun coins on Base, BNB Chain and other EVM chains?

Yes. Coin routes take an EVM chain id when the mint is a 0x address. Wallet routes cover every chain pump.fun knows. The live stream carries pump.fun trades on Solana and 11 EVM chains.

#How fresh is the data?

Live reads are seconds old at most. Each answer's meta.cache says whether it was fetched just now (live), served from a fresh cache, or served while a refresh runs (stale). The WebSocket delivers trades as pump.fun's own live data does.

#Is pumpfomo part of pump.fun?

No. pumpfomo is independent and not affiliated with pump.fun or fomo.family.

#Where to go next

• The API reference has every pump.fun endpoint with a real answer you can read before writing code.
• For live trades, new coins and callouts, read the pump.fun WebSocket API guide.
• If you also want fomo.family traders, the fomo.family API guide covers that side.
• Get a free key and make your first call.