Claim Pump.fun Creator Fees

Claim your creator fees now

Connect a wallet, see the amount, claim in one click. Rent, creator fees and cashback come together.

Free check — nothing happens until you press Claim

Open the Claim SOL app →Prefer code? Claim through the API ↓

Token creators on Pump.fun automatically receive a percentage of every trade executed on their tokens. These trading fees accumulate over time and can be collected programmatically across bonding curve trades, graduated PumpSwap trades, and non-SOL quote mints such as USDC.

API Endpoints:

GET https://pumpdev.io/api/claim-account — Check claimable balance (read-only)
POST https://pumpdev.io/api/claim-account — Build claim transaction

Before You Start

Four things trip up most first-time claims. Check them before debugging anything else.

No API key is required. Both /api/claim-account methods are open endpoints — send the request without an Authorization header.

publicKey must be the wallet that signs. The address you send as publicKey becomes the transaction's fee payer and its only required signer. If you pass one wallet and sign with a different keypair, the transaction is built fine but the RPC rejects it with a signature verification error. Derive it from the keypair rather than passing it separately:

const keypair = Keypair.fromSecretKey(bs58.decode(PRIVATE_KEY));
const publicKey = keypair.publicKey.toBase58();  // always in sync with the signer

The signing wallet needs a small SOL balance. Roughly 0.01 SOL covers the network fee, your priority fee, and the service commission. This holds even when the fees you are claiming are denominated in USDC or another SPL token — the transaction itself is still paid for in SOL. An unfunded wallet fails on-chain, not at the API.

Sign and send promptly. The returned transaction carries a recent blockhash that expires in about 60 seconds. Build it, sign it, send it. Don't queue it or cache it for later.

Check Claimable Balance

Before claiming, you can check how much is available using the read-only balance endpoint. No transaction is built — it simply returns the current claimable amounts.

Endpoint: GET https://pumpdev.io/api/claim-account

Results may be cached in-process for up to ~3 minutes.

Query Parameters

Parameter	Type	Required	Description
`publicKey`	string	Yes	Creator wallet public key
`mint`	string	No	Token mint address. Enables graduated/fee-sharing checks
`quoteMint`	string	No	Quote mint override (used only when `mint` is omitted)

Response

{
  "publicKey": "YourWalletPublicKey",
  "mint": "TokenMintAddress",
  "pumpBalance": 0.123,
  "pumpSwapBalance": 0.456,
  "totalClaimable": 0.579,
  "graduated": true,
  "hasFeeSharing": false,
  "quoteMint": "So11111111111111111111111111111111111111112",
  "isNativeQuote": true,
  "shareholders": []
}

Field	Description
`pumpBalance`	Claimable fees from the Pump bonding curve creator vault
`pumpSwapBalance`	Claimable fees from the PumpSwap creator vault (graduated tokens only)
`totalClaimable`	Sum of both balances
`graduated`	Whether the token has graduated to PumpSwap
`hasFeeSharing`	Whether fee sharing is configured for this token
`quoteMint`	The quote mint used for fee denomination
`isNativeQuote`	`true` if fees are in native SOL, `false` for USDC or other SPL tokens
`shareholders`	Array of `{ address, sharePercent }` if fee sharing is active

Example: Check Balance Then Claim

const API_URL = 'https://pumpdev.io';

// 1. Check claimable balance
const balanceRes = await fetch(
  `${API_URL}/api/claim-account?publicKey=${publicKey}&mint=${tokenMint}`
);
const balance = await balanceRes.json();

console.log(`Claimable: ${balance.totalClaimable} ${balance.isNativeQuote ? 'SOL' : balance.quoteMint}`);
console.log(`  Pump: ${balance.pumpBalance}`);
console.log(`  PumpSwap: ${balance.pumpSwapBalance}`);

if (balance.totalClaimable <= 0) {
  console.log('No fees to claim.');
  return;
}

// 2. Build and send claim transaction
const claimRes = await fetch(`${API_URL}/api/claim-account`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ publicKey, mint: tokenMint })
});

// ... sign and send

Claim Transaction

Request Parameters

Parameter	Type	Required	Description
`publicKey`	string	Yes	Creator wallet public key
`mint`	string	No*	Token mint address. Strongly recommended for all modern claims and required for fee sharing
`quoteMint`	string	No	Quote mint to sweep when `mint` is omitted. Use only for quote-specific legacy sweeps
`priorityFee`	number	No	Priority fee in SOL (default: 0.0005)

*Important: Pass mint whenever possible. It lets the API resolve the coin's quote mint and include the correct V2 fee instructions for graduated coins, fee sharing, and non-SOL quote mints. If you omit mint, /api/claim-account defaults to a wrapped-SOL creator-vault sweep unless you explicitly provide quoteMint.

Non-SOL quote mints: When the coin is quoted in USDC or another SPL token, claimed fees are sent to your quote-token ATA instead of native SOL. The endpoint creates that ATA for you when needed.

Response: Binary serialized unsigned VersionedTransaction

If you're the sole fee recipient, pass your wallet address and the token mint. Call GET /api/claim-account first — building a claim transaction for an empty vault just returns No claimable fees found for this mint.

import { VersionedTransaction, Connection, Keypair } from '@solana/web3.js';
import bs58 from 'bs58';

const API_URL = 'https://pumpdev.io';
const RPC_URL = 'https://api.mainnet-beta.solana.com';
const PRIVATE_KEY = 'YourBase58PrivateKey';

async function claimCreatorFees() {
  const keypair = Keypair.fromSecretKey(bs58.decode(PRIVATE_KEY));
  const publicKey = keypair.publicKey.toBase58();

  // Build claim transaction
  const response = await fetch(`${API_URL}/api/claim-account`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      publicKey: publicKey,
      mint: 'YourTokenMintAddress'
    })
  });

  if (response.status !== 200) {
    const error = await response.json();
    console.error('API Error:', error);
    return;
  }

  // Deserialize, sign, and send
  const data = await response.arrayBuffer();
  const tx = VersionedTransaction.deserialize(new Uint8Array(data));
  tx.sign([keypair]);

  const connection = new Connection(RPC_URL, 'confirmed');
  const signature = await connection.sendTransaction(tx, {
    skipPreflight: false,
    maxRetries: 3
  });

  console.log('Fees claimed:', signature);
}

claimCreatorFees();

Mint-Less Sweep (Quote-Specific / Fallback)

Omitting mint sweeps the creator vault for a single quote mint — wrapped SOL by default, or the quoteMint you name. It skips all per-mint resolution, which makes it a useful fallback when a mint-specific claim errors out (see Claim fails with mint, works without it).

A mint-less sweep only collects one vault

Because no mint is resolved, this call cannot see:

graduated PumpSwap creator fees — those live in a separate PumpSwap vault
fees on non-SOL quoted coins, unless you pass the matching quoteMint
fee-sharing vaults — those are keyed by the sharing config PDA, not your wallet

It will return a valid transaction and succeed while leaving those fees unclaimed. Treat it as a diagnostic fallback, not a permanent solution — once you know why the mint-specific call failed, go back to passing mint.

Use it deliberately for legacy SOL-only flows, or when you know the exact quote mint you want to target:

await fetch(`${API_URL}/api/claim-account`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    publicKey: publicKey,
    quoteMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // Example: USDC
  })
});

If you omit both mint and quoteMint, the request defaults to the wrapped-SOL creator vault.

If you configured fee sharing on pump.fun (e.g. 50/50 split between two wallets), you can either:

Call /api/claim-account with mint, or
Use the dedicated /api/claim-distribute endpoint

We recommend /api/claim-distribute for explicit fee-sharing flows. It reads the on-chain sharing config, handles graduated PumpSwap creator fees, and distributes the final amount to all shareholders.

API Endpoint: POST https://pumpdev.io/api/claim-distribute

Parameter	Type	Required	Description
`publicKey`	string	Yes	Any wallet (pays tx fees, doesn't need to be a shareholder)
`mint`	string	Yes	Token mint address
`priorityFee`	number	No	Priority fee in SOL (default: 0.0005)

This instruction is permissionless — any wallet can trigger it. The on-chain config decides who gets paid and how much. For USDC and other SPL quote mints, shareholder ATAs are included automatically.

async function distributeCreatorFees() {
  const keypair = Keypair.fromSecretKey(bs58.decode(PRIVATE_KEY));
  const publicKey = keypair.publicKey.toBase58();

  const response = await fetch(`${API_URL}/api/claim-distribute`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      publicKey: publicKey,
      mint: 'YourTokenMintAddress'
    })
  });

  if (response.status !== 200) {
    const error = await response.json();
    console.error('API Error:', error);
    return;
  }

  const data = await response.arrayBuffer();
  const tx = VersionedTransaction.deserialize(new Uint8Array(data));
  tx.sign([keypair]);

  const connection = new Connection(RPC_URL, 'confirmed');
  const signature = await connection.sendTransaction(tx, {
    skipPreflight: false,
    maxRetries: 3
  });

  console.log('Fees distributed to all shareholders:', signature);
}

distributeCreatorFees();

When you set up fee sharing on pump.fun:

A sharing config is created on-chain with your shareholders and their percentages
The token's bonding curve creator field is updated to point to the sharing config PDA
Fees accumulate in a vault derived from the sharing config (not your wallet)
The quote-aware V2 distribution flow moves any graduated PumpSwap fees into the Pump creator vault, then distributes from that vault to all shareholders

The API handles all of this automatically — just pass the mint and it detects the config, fetches shareholders, and builds the correct instruction.

Why Does It Fail Without Mint?

Without mint, the API cannot resolve the token's fee-sharing config or quote mint. In modern flows that means it can miss graduated PumpSwap fees, non-SOL quote fees, or the fee-sharing vault entirely.

Claim Multiple Tokens

Use /api/claim-all to claim from multiple tokens at once. Auto-detects fee sharing per token.

Endpoint: POST https://pumpdev.io/api/claim-all

Parameter	Type	Required	Description
`publicKey`	string	Yes	Creator wallet public key
`mints`	string[]	Yes	Array of token mint addresses (max 10)
`priorityFee`	number	No	Priority fee in SOL (default: 0.0005)

const response = await fetch(`${API_URL}/api/claim-all`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    publicKey: publicKey,
    mints: ['mint1...', 'mint2...', 'mint3...']
  })
});

const result = await response.json();
// result.transactions = [{ mint, transaction, quoteMint, graduated }, ...]
// result.count = number of successful transactions
// result.errors = number of failed transactions

Response Format

{
  "transactions": [
    {
      "mint": "mint1...",
      "transaction": "base58-encoded-tx",
      "quoteMint": "So11111111111111111111111111111111111111112",
      "graduated": false
    },
    {
      "mint": "mint2...",
      "transaction": "base58-encoded-tx",
      "quoteMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
      "graduated": true
    },
    { "mint": "mint3...", "error": "No claimable fees available" }
  ],
  "count": 2,
  "errors": 1
}

Each token is checked individually — some may use fee sharing and others may not. Tokens that have graduated to PumpSwap will have graduated: true, and successful entries include the resolved quoteMint.

Understanding Creator Fee Mechanics

Every time someone trades your token on Pump.fun, a portion of that trade volume is allocated to you as the creator.

Fee Rates

Bonding curve: 0.3% creator fee
PumpSwap (graduated): 0.05% - 0.95% creator fee (varies by market cap)

Optimization Strategies

Consolidate Claims - Accumulate fees over time before claiming to minimize transaction costs
Include Mint - Always include the mint parameter for fee sharing, graduated coins, and any non-SOL quote mint
Dynamic Priority Fees - Adjust priority fees based on network congestion

Error Handling

Error	Cause	Fix
`publicKey is required`	Missing wallet address	Add `publicKey` to request body
`Invalid publicKey`	Malformed Solana address	Verify the public key format
`Invalid mint address`	Malformed mint	Check the mint address
`No claimable creator fees available`	No fees to claim on the default wrapped-SOL sweep	Pass `mint` for a mint-specific claim, or pass `quoteMint` for a quote-specific sweep
`No claimable fees found for this mint`	No fees for specified mint	Verify the mint and check if fees have accumulated
`mints must be a non-empty array`	Missing or empty mints array on `/api/claim-all`	Provide at least one mint address
`Maximum 10 mints per request`	Too many mints on `/api/claim-all`	Reduce to 10 or fewer mints
`No fee sharing config found`	Mint doesn't have fee sharing	Use `/api/claim-account` instead
`mint is required`	Missing mint on `/api/claim-distribute`	Add `mint` to request body
`Could not resolve quote mint for <mint>` (500)	The API could not read a bonding curve or a PumpSwap pool for that mint	See below — retry first, then verify the mint, then fall back to a mint-less sweep
Transaction fails on-chain	Usually missing `mint`, wrong quote context, or no fees available	Pass `mint` for the token you are claiming. For explicit fee-sharing flows, use `/api/claim-distribute`

These errors surface on the signed transaction, not on the API response:

Error	Cause	Fix
`Transaction signature verification failure`	The `publicKey` in the request body isn't the wallet you signed with	Derive `publicKey` from the signing keypair — see Before You Start
`Attempt to debit an account but found no record of a prior credit`	The signing wallet holds no SOL	Fund it with ~0.01 SOL for fees and commission
`Blockhash not found`	The transaction was built more than ~60s before it was sent	Rebuild the transaction instead of retrying the old one

Claim fails with `mint`, works without it

A 500 Could not resolve quote mint for <mint> means the API resolved neither a bonding curve nor a PumpSwap pool for that mint, so it cannot tell which quote mint the fees are denominated in. Work through it in this order:

Retry once. This can be a transient RPC read failure rather than a property of the token.
Verify the mint. It must be the token's mint address, not the bonding curve, pool, or your own wallet. A malformed address returns Invalid mint address instead, so a well-formed but wrong address is the case to watch for.
Confirm fees exist with GET /api/claim-account?publicKey=...&mint=..., which reports graduated, hasFeeSharing, and quoteMint and tells you which vault the money is actually in.
Fall back to a mint-less sweep only to unblock yourself — and read the warning under Mint-Less Sweep first, because it collects native SOL from one vault only and silently leaves graduated, USDC-quoted, and fee-sharing balances behind.

Raising priorityFee does not fix this

A priority fee only affects how quickly a valid transaction is included. It cannot change whether the API can build one, and it cannot fix a signature or funding error. The default is 0.0005 SOL — lower it only for latency-insensitive claims, and raise it only when a valid transaction is confirming too slowly.

Claim Cashback Rewards (Traders)

For cashback-enabled tokens, traders can claim accumulated rewards from their trading activity. See Claim Cashback for the full API and examples.

Next Steps

⚡ Lightning Trade — One-call buy/sell
⚡ Lightning Setup — Create a Lightning wallet
Claim Cashback — Trader cashback rewards on cashback-enabled tokens
Distribute Creator Fees — Fee sharing / reward distribution to multiple addresses
Trade API — Client-side buy and sell
Token Creation — Create new tokens
SOL Transfers — Transfer SOL between wallets

Before You Start​

Check Claimable Balance​

Query Parameters​

Response​

Example: Check Balance Then Claim​

Claim Transaction​

Request Parameters​

Standard Claim (No Fee Sharing)​

Mint-Less Sweep (Quote-Specific / Fallback)​

Fee Sharing — Dedicated Distribution Endpoint​

How Fee Sharing Works​

Why Does It Fail Without Mint?​

Claim Multiple Tokens​

Response Format​

Understanding Creator Fee Mechanics​

Fee Rates​

Optimization Strategies​

Error Handling​

Claim fails with mint, works without it​

Claim Cashback Rewards (Traders)​

Next Steps​