Skip to main content

Claim Pump.fun Cashback Rewards

Claim your cashback 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 ↓

Pump.fun cashback is a trader reward feature where creator fees are redirected back to the users who trade cashback-enabled tokens. Instead of the token creator receiving trading fees, every buyer and seller automatically accumulates cashback in SOL. Rewards build up with each trade and can be claimed at any time through a single API call.

Cashback is deprecated for new launches

Pump.fun no longer lets new cashback coins be created; new launches use Holder Rewards (holderReward: true) instead. Existing cashback coins are not affected: trading them still accrues cashback, and everything accrued stays claimable with this endpoint.

This endpoint generates an unsigned VersionedTransaction that claims your accumulated cashback from the Pump.fun bonding curve, PumpSwap (AMM), or both. You sign the transaction locally and broadcast it through your own Solana RPC.

API Endpoints:

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

Check Claimable Cashback​

Before claiming, you can check how much cashback 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-cashback

Query Parameters​

ParameterTypeRequiredDescription
publicKeystringYesYour Solana wallet public key (the wallet that traded)
programstringNo"both" (default), "pump", or "pumpswap"
mintstringNoToken mint address (resolves quote context for non-SOL pairs)
quoteMintstringNoQuote mint override (used only when mint is omitted)

Response​

{
  "publicKey": "YourWalletPublicKey",
  "pumpCashback": 0.123,
  "pumpSwapCashback": 0.456,
  "totalCashback": 0.579,
  "program": "both",
  "quoteMint": "So11111111111111111111111111111111111111112",
  "isNativeQuote": true
}
FieldDescription
pumpCashbackClaimable cashback from bonding curve trades
pumpSwapCashbackClaimable cashback from PumpSwap (graduated) trades
totalCashbackSum of both
programWhich programs were checked
quoteMintThe quote mint used for cashback denomination
isNativeQuotetrue if cashback is in native SOL

Example: Check Balance Then Claim​

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

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

console.log(`Claimable cashback: ${balance.totalCashback} SOL`);
console.log(`  Pump: ${balance.pumpCashback}`);
console.log(`  PumpSwap: ${balance.pumpSwapCashback}`);

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

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

// ... sign and send

Prerequisites​

Before claiming cashback, make sure you have:

  • A Solana wallet with a small SOL balance (to cover transaction fees)
  • Previous buy or sell trades on a cashback-enabled token
  • Node.js with @solana/web3.js and bs58 installed (for JavaScript examples)

Cashback-enabled tokens were created with cashbackEnabled: true during Token Creation, before pump.fun deprecated cashback for new launches. Not all tokens on Pump.fun have cashback enabled — only those where the creator opted in.

Request Parameters​

ParameterTypeRequiredDescription
publicKeystringYesYour Solana wallet public key (the wallet that traded)
programstringNo"both" (default), "pump", or "pumpswap"
priorityFeenumberNoPriority fee in SOL (default: 0.0005)

Note: Cashback from bonding curve trades is paid in native SOL. Cashback from PumpSwap (graduated) trades is paid in WSOL, which the transaction automatically unwraps to native SOL for you.

Response Format​

Success (200): Returns a binary serialized unsigned VersionedTransaction. Deserialize it, sign with your wallet keypair, and send to Solana.

Error (non-200): Returns a JSON object with an error message:

{
  "error": "No cashback available for this wallet"
}

JavaScript Example​

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 claimCashback() {
  const keypair = Keypair.fromSecretKey(bs58.decode(PRIVATE_KEY));
  const publicKey = keypair.publicKey.toBase58();

  // 1. Build the claim transaction
  const response = await fetch(`${API_URL}/api/claim-cashback`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      publicKey: publicKey,
      program: 'both'      // Claim from both bonding curve and PumpSwap
    })
  });

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

  // 2. Deserialize the unsigned transaction
  const data = await response.arrayBuffer();
  const tx = VersionedTransaction.deserialize(new Uint8Array(data));

  // 3. Sign with your wallet
  tx.sign([keypair]);

  // 4. Send to Solana
  const connection = new Connection(RPC_URL, 'confirmed');

  try {
    const signature = await connection.sendTransaction(tx, {
      skipPreflight: false,
      maxRetries: 3
    });

    console.log('Cashback claimed!');
    console.log('Signature:', signature);

    // Wait for confirmation
    const confirmation = await connection.confirmTransaction(signature, 'confirmed');

    if (confirmation.value.err) {
      console.error('Transaction failed:', confirmation.value.err);
    } else {
      console.log('Cashback claim confirmed!');
    }
  } catch (err) {
    console.error('Send error:', err.message);
  }
}

claimCashback();

cURL Example​

You can also call the API with cURL and handle the binary response in any language:

curl -X POST https://pumpdev.io/api/claim-cashback \
  -H "Content-Type: application/json" \
  -d '{
    "publicKey": "YourWalletPublicKey",
    "program": "both"
  }' \
  --output claim_tx.bin

The response is a raw binary VersionedTransaction. Deserialize it with your language's Solana SDK, sign it, and send it to your RPC.

How Cashback Works​

Cashback is a protocol-level feature built into Pump.fun's bonding curve and PumpSwap programs. Here is how the reward lifecycle works from token creation to claiming:

  1. A token creator launched a coin with cashbackEnabled: true during Token Creation. This flags the token for cashback at the protocol level. (New cashback coins can no longer be created; new launches use Holder Rewards.)
  2. When any user buys or sells that token, the creator fee (which would normally go to the token creator) is instead redirected into a UserVolumeAccumulator account for the trader.
  3. Bonding curve cashback accumulates as native lamports (SOL). PumpSwap cashback accumulates as WSOL, which is automatically unwrapped to native SOL when claimed.
  4. Users call this /api/claim-cashback endpoint to withdraw their accumulated rewards. The more you trade cashback-enabled tokens, the more rewards you accumulate.
  5. All buy and sell transactions on cashback-enabled tokens automatically include the proper accounts for cashback tracking — no extra setup is needed from the trader.

Bonding Curve vs PumpSwap Cashback​

Tokens on Pump.fun go through two phases, and cashback works slightly differently in each:

PhaseProgramCashback CurrencyWhen It Applies
Bonding curvepumpNative SOL (lamports)Before the token graduates to Raydium/PumpSwap
PumpSwap (AMM)pumpswapWSOL (auto-unwrapped)After graduation to the PumpSwap AMM

Using program: "both" (the default) claims from both sources in a single transaction, which saves on transaction fees.

Program Options​

The program parameter controls which cashback pool to claim from:

ValueDescription
"both"Claim from both Pump (bonding curve) and PumpSwap (AMM) in one transaction. This is the default and recommended option.
"pump"Claim only from bonding curve trades (native SOL). Use this if you only traded before graduation.
"pumpswap"Claim only from PumpSwap/AMM trades (WSOL, auto-unwrapped to SOL). Use this if you only traded after graduation.

Error Handling​

The API returns JSON error responses when something goes wrong. Here are the common errors and how to resolve them:

Error MessageCauseSolution
publicKey is requiredMissing wallet public key in request bodyInclude your Solana wallet public key
Invalid publicKey addressMalformed Solana addressVerify the address is a valid base58-encoded Solana public key
program must be 'both', 'pump', or 'pumpswap'The program parameter is not one of the allowed valuesUse "both", "pump", or "pumpswap"
Transaction fails on-chainNo cashback available, insufficient SOL for fees, or network congestionEnsure you've traded cashback-enabled tokens and have enough SOL for fees. Try again with a higher priorityFee

Handling No Cashback Available​

If you haven't traded any cashback-enabled tokens, the API will return an error. Not all tokens on Pump.fun have cashback — it depends on whether the creator enabled it during token creation. You can check if a token has cashback enabled using the Data API WebSocket feeds, which include token metadata.

Troubleshooting​

My transaction was confirmed but I didn't receive SOL This can happen if your accumulated cashback was very small (dust amounts). Check the transaction on a Solana block explorer to verify the exact amounts transferred.

I traded a token but have no cashback to claim The token may not have cashback enabled. Only tokens created with cashbackEnabled: true accumulate trader rewards. Standard tokens send fees to the creator instead.

WSOL not unwrapping to SOL PumpSwap cashback is paid in WSOL. The claim transaction includes an unwrap instruction that converts WSOL to native SOL automatically. If you see WSOL in your wallet instead of SOL, the unwrap instruction may have failed — try claiming again.

Transaction keeps failing During high network congestion, transactions may fail. Increase the priorityFee parameter (e.g., from 0.0005 to 0.001 SOL) and set maxRetries higher when sending the transaction.

Next Steps​

Last updated on