Solana Copy Trading: How to Pick Wallets Worth Copying

Copy trading sounds simple. Find a Solana wallet that wins, copy its buys and sells, and win with it.

The copying is the easy part. Picking the wallet is where most copy traders lose money. A wallet can top a leaderboard because it got lucky once, because it launched the token itself, or because it buys so early that nobody copying it can get the same price.

This guide covers why "top wallets" lists mislead, what to check on a wallet before you copy it, the red flags, how to size copies, and when to stop. There's a short Node.js script that summarises a wallet's recent swaps from public chain data, and a section on the settings in the AllenHark Solana Wallet Copy Trader that help. No promises: copying a wallet doesn't copy its results.

Disclosure: AllenHark sells the Solana Wallet Copy Trader described here. Nothing in this guide is financial advice.

The short answer

• Judge a wallet on many closed trades over weeks, not on one big win or one good day.
• Look at the spread of results, not the win rate. Check its worst trades, and its PnL without its single best token.
• Skip wallets you can't follow: devs and insiders, block-0 snipers, wallets that sell within seconds, and wallets that buy big into thin pools.
• Copy small, spread across a few wallets, and set a budget and a daily loss limit.
• Watch a wallet in practice, with virtual SOL, before you copy it with real SOL.

Why most "top wallets" lists mislead

A list of the most profitable wallets is sorted by results. That's the problem: it shows who did well, not why, and not whether you could have done the same by copying them.

Survivorship: you only see the winners

Many wallets trade memecoins every day. Some will have a great month by chance alone. A list sorted by PnL picks those up along with any skilled traders, and it can't tell them apart. The wallets that tried the same thing and lost aren't on the list.

One lucky trade

A wallet's whole PnL can come from one token that ran. Take that trade out and the rest may be a steady loss. Copy it, and you copy the steady loss while you wait for the next lucky token.

The wallet is the dev, an insider or a bundler

Some wallets win because they knew. A dev can buy its own token in the same transaction that creates it, before anyone else can. Wallets the dev controls can buy in the same block as the launch, often sent together as a bundle. Their PnL comes from selling to the people who bought after them, and a copier always buys after them.

Wash trading and bait

A wallet can trade with itself, or between wallets one person controls, to fake volume or a PnL that looks good. And some wallets know they're being copied: they buy to pull copiers in, then sell into them. The Solana Wallet Copy Trader guide calls these wallets bait.

Block-0 buyers: a price you can't get

A wallet that buys in the same block as a token's creation gets the bonding curve's cheapest price. A copy only goes out once that buy is seen, so it lands after it, at a price that buy (and often other copiers) has already moved. A Solana slot is about 200 ms, and on a busy launch a block or two later can be a very different price. That wallet's entry isn't one you can copy. How block-0 sniping works goes deeper.

What to check on a wallet before you copy it

Open the wallet's history in a block explorer such as Solscan, or run the script below. These are the checks that matter:

Win rate isn't the whole story

An illustrative example, not a real wallet: 7 wins of +0.05 SOL and 3 losses of −0.2 SOL is a 70 % win rate, and it loses 0.25 SOL. A wallet with a 40 % win rate can still come out ahead if its losses are small and its wins are large.

So look at the spread. What does a typical trade do (the median)? What did its worst three trades lose? What's left if you take out its single best token?

Your copy pays more than the wallet did

Every copy pays its own costs: the network and priority fee, a relay tip, and the slippage of buying after the price has moved. On a small copy, those take a bigger share than on the wallet's own, bigger buy. A wallet that makes a thin edge on each trade can be a loss once you copy it.

Check a wallet yourself: a Node.js script

This script reads a wallet's recent transactions from public chain data and summarises its swaps against SOL: the number of trades, the SOL in and out per token, wins and losses on the tokens it sold out of, its PnL without its best token, how long it held, and the fees it paid.

It uses two standard Solana RPC methods:

• getSignaturesForAddress lists the wallet's transactions, newest first, up to 1,000 per call.
• getTransaction returns each one with the wallet's SOL and token balances before and after it.

For each transaction, the script compares the wallet's SOL (counting wrapped SOL as SOL) with its balance of each token. One token in and SOL out is a buy; one token out and SOL in is a sell. Anything else is counted as "other".

To run it you need Node.js (we tested on version 24):

mkdir wallet-check && cd wallet-check
npm init -y
npm install @solana/web3.js@1
# save the script below as wallet-summary.mjs, then:
node wallet-summary.mjs <WALLET_ADDRESS> 100

Install version 1 (@1): the script is written for the web3.js 1.x API, and we tested it with 1.99.0.

// wallet-summary.mjs: a rough summary of a Solana wallet's recent swaps, from public chain data.
// Usage: node wallet-summary.mjs <WALLET_ADDRESS> [transactions to read, default 100]
// Env: RPC_URL (default: Solana's public mainnet endpoint), DELAY_MS (pause between calls, default 300).
// It is an estimate, not a PnL statement: read the notes under the script.
import { Connection, PublicKey } from "@solana/web3.js";

const RPC_URL = process.env.RPC_URL ?? "https://api.mainnet.solana.com";
const DELAY_MS = Number(process.env.DELAY_MS ?? 300);
// Wrapped SOL (Token Program and Token Extension Program native mints) counts as SOL.
const WSOL = new Set(["So11111111111111111111111111111111111111112", "9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP"]);

const [address, count = "100"] = process.argv.slice(2);
if (!address) {
  console.error("Usage: node wallet-summary.mjs <WALLET_ADDRESS> [transactions to read]");
  process.exit(1);
}
let owner;
try {
  owner = new PublicKey(address);
} catch {
  console.error(`Not a Solana address: ${address}`);
  process.exit(1);
}
const wallet = owner.toBase58();
const limit = Math.min(Math.max(parseInt(count, 10) || 100, 1), 5000);
const rpc = new Connection(RPC_URL, "confirmed");
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const sol = (lamports) => (lamports / 1e9).toFixed(4);
const dur = (s) => (s < 120 ? `${Math.round(s)} s` : s < 7200 ? `${Math.round(s / 60)} min` : s < 172800 ? `${(s / 3600).toFixed(1)} h` : `${(s / 86400).toFixed(1)} days`);
const median = (xs) => {
  if (xs.length === 0) return NaN;
  const s = [...xs].sort((a, b) => a - b);
  const m = Math.floor(s.length / 2);
  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
};

// 1. The wallet's signatures, newest first, at most 1,000 per call.
const sigs = [];
for (let before; sigs.length < limit; ) {
  const want = Math.min(1000, limit - sigs.length);
  const page = await rpc.getSignaturesForAddress(owner, { limit: want, before });
  sigs.push(...page);
  if (page.length < want) break;
  before = page[page.length - 1].signature;
  await sleep(DELAY_MS);
}

// 2. Each transaction, oldest first: the wallet's SOL change and its change in each token.
const swaps = [];
let failed = 0, other = 0, unread = 0, fees = 0;
for (const { signature } of sigs.reverse()) {
  await sleep(DELAY_MS);
  let tx;
  try {
    tx = await rpc.getParsedTransaction(signature, { maxSupportedTransactionVersion: 1, commitment: "confirmed" });
  } catch {
    tx = null;
  }
  if (!tx?.meta) { unread++; continue; }
  const keys = tx.transaction.message.accountKeys.map((k) => k.pubkey.toBase58());
  const i = keys.indexOf(wallet);
  const fee = i === 0 ? tx.meta.fee : 0; // the first account pays the network and priority fee
  fees += fee;
  if (tx.meta.err) { failed++; continue; } // a failed transaction still paid its fee
  let lamports = i >= 0 ? tx.meta.postBalances[i] - tx.meta.preBalances[i] : 0; // fee included
  const tokens = new Map(); // mint -> change in base units
  const add = (b, sign) => {
    if (b.owner !== wallet) return;
    const raw = BigInt(b.uiTokenAmount.amount) * sign;
    if (WSOL.has(b.mint)) lamports += Number(raw);
    else tokens.set(b.mint, (tokens.get(b.mint) ?? 0n) + raw);
  };
  for (const b of tx.meta.preTokenBalances ?? []) add(b, -1n);
  for (const b of tx.meta.postTokenBalances ?? []) add(b, 1n);
  for (const [mint, d] of tokens) if (d === 0n) tokens.delete(mint);
  // A swap here is one token in for SOL out (a buy), or one token out for SOL in (a sell).
  const [mint, delta] = tokens.size === 1 ? [...tokens][0] : [];
  const beforeFee = lamports + fee;
  if (delta > 0n && beforeFee < 0) swaps.push({ side: "buy", mint, amount: delta, lamports, time: tx.blockTime });
  else if (delta < 0n && beforeFee > 0) swaps.push({ side: "sell", mint, amount: -delta, lamports, time: tx.blockTime });
  else other++; // transfers, airdrops, fee claims, swaps priced in another token, anything else
}

// 3. Per token: SOL in and out, and whether the wallet sold out of it inside this window.
const book = new Map();
for (const s of swaps) {
  const p = book.get(s.mint) ?? { mint: s.mint, buys: 0, sells: 0, spent: 0, got: 0, bought: 0n, held: 0n, early: false, opened: null, holds: [] };
  book.set(s.mint, p);
  if (s.side === "buy") {
    if (p.held === 0n) p.opened = s.time;
    p.buys += 1;
    p.spent -= s.lamports;
    p.bought += s.amount;
    p.held += s.amount;
    continue;
  }
  if (s.amount > p.held) p.early = true; // it sold tokens bought before this window
  p.sells += 1;
  p.got += s.lamports;
  p.held = s.amount > p.held ? 0n : p.held - s.amount;
  if (p.held * 100n <= p.bought && p.opened != null) {
    if (s.time != null) p.holds.push(s.time - p.opened); // sold out, dust aside: one round trip
    p.held = 0n;
    p.opened = null;
  }
}
const all = [...book.values()];
const closed = all.filter((p) => !p.early && p.buys > 0 && p.held === 0n).map((p) => ({ ...p, net: p.got - p.spent }));
const open = all.filter((p) => !p.early && p.held > 0n);
const early = all.filter((p) => p.early);
const nets = closed.map((p) => p.net).sort((a, b) => b - a);
const holds = closed.flatMap((p) => p.holds);
const buySizes = swaps.filter((s) => s.side === "buy").map((s) => -s.lamports);
const times = sigs.map((s) => s.blockTime).filter(Boolean);
const span = times.length ? Math.max(...times) - Math.min(...times) : 0;
const total = nets.reduce((a, b) => a + b, 0);

console.log(`Wallet ${wallet}`);
console.log(`Read ${sigs.length} transactions covering ${dur(span)}: ${swaps.length} SOL swaps, ${failed} failed, ${other} other, ${unread} unreadable`);
console.log(`Fees it paid as fee payer: ${sol(fees)} SOL`);
console.log(buySizes.length ? `Median buy: ${sol(median(buySizes))} SOL over ${buySizes.length} buys` : "No buys against SOL in this window");
console.log(`Tokens bought and sold out inside the window: ${closed.length}`);
if (closed.length) {
  console.log(`  wins ${nets.filter((n) => n > 0).length}, losses ${nets.filter((n) => n <= 0).length}, net ${sol(total)} SOL`);
  console.log(`  best ${sol(nets[0])}, worst ${sol(nets[nets.length - 1])}, median ${sol(median(nets))} SOL`);
  console.log(`  net without its best token: ${sol(total - nets[0])} SOL`);
  if (holds.length) console.log(`  median hold ${dur(median(holds))}; ${holds.filter((h) => h < 60).length} of ${holds.length} round trips under 60 s`);
}
console.log(`Still holding, not counted: ${open.length} tokens, ${sol(open.reduce((a, p) => a + p.spent - p.got, 0))} SOL in after sells`);
console.log(`Sold tokens it bought before this window, not counted: ${early.length}`);
for (const p of closed.sort((a, b) => b.net - a.net)) {
  console.log(`  ${p.mint.slice(0, 6)}…  ${p.buys} buys ${p.sells} sells  in ${sol(p.spent)}  out ${sol(p.got)}  net ${sol(p.net)} SOL`);
}

Here is its output on a set of made-up test transactions, served by a local test server, not a real wallet. The figures match a hand calculation, and the test wallet's address is left out:

Wallet <test wallet>
Read 12 transactions covering 15 min: 9 SOL swaps, 1 failed, 2 other, 0 unreadable
Fees it paid as fee payer: 0.0001 SOL
Median buy: 0.3760 SOL over 4 buys
Tokens bought and sold out inside the window: 3
  wins 2, losses 1, net 0.1999 SOL
  best 0.3000, worst -0.3000, median 0.2000 SOL
  net without its best token: -0.1000 SOL
  median hold 100 s; 1 of 3 round trips under 60 s
Still holding, not counted: 1 tokens, 0.2520 SOL in after sells
Sold tokens it bought before this window, not counted: 1
  EUfJSz…  1 buys 2 sells  in 1.0021  out 1.3020  net 0.3000 SOL
  21Y9xa…  1 buys 1 sells  in 0.1020  out 0.3020  net 0.2000 SOL
  4fRkeE…  1 buys 1 sells  in 0.5000  out 0.2000  net -0.3000 SOL

How to read it

• "covering 15 min" is the window. A busy wallet's last 100 transactions can cover only minutes; read more (the script allows up to 5,000) to cover weeks.
• "net without its best token" is the one-lucky-trade check. Here a small gain turns into a loss: one token made the result.
• "median hold" and "under 60 s" show how quickly it flips. Quick flips are hard to copy.
• "Still holding" and "bought before this window" are left out, because the script can't see both ends of those trades.
• "other" is anything that isn't a simple swap against SOL: transfers, airdrops, fee claims, trades priced in USDC or another token.

When we tried the script on Solana's public endpoint, two of the three wallets we picked from recent Pump.fun trades showed 25 transactions in 2 to 5 seconds, none of them a simple SOL swap: bots, not traders a copy can follow. That's the "person or bot" check doing its job.

Why it's an estimate

• Fees and tips are in the numbers. The SOL in and out includes the network and priority fee when the wallet pays it, and any tip sent inside the transaction.
• Token account rent. Buying a token usually opens a token account, which holds a small rent deposit until the account is closed. A wallet that never closes its accounts looks a little worse than it is.
• Wrapped SOL counts as SOL. Both native mints listed in Solana's wrapped SOL docs are treated as SOL.
• Routes. A swap routed through other tokens counts only if those tokens net to zero in the wallet. A trade priced in USDC or another token isn't counted as a SOL swap.
• Transfers. Tokens moved between wallets aren't trades. A trader who buys from one wallet and sells from another will look wrong.
• The window. Unrealized PnL isn't counted at all, so a wallet holding a big loser can look better than it is.
• Failed transactions are counted, and their fees are included: Solana charges the fee even when a transaction fails.
• Transaction versions. The script sets maxSupportedTransactionVersion: 1, so the RPC also returns v1 transactions. With a lower value it refuses any newer transaction with an error; the getTransaction docs explain the setting.

About the endpoint. The default is Solana's public mainnet endpoint, which is rate-limited (100 requests per 10 seconds per IP, and 40 per 10 seconds for a single RPC method, per Solana's RPC endpoints page) and isn't meant for production apps. The script waits DELAY_MS (300 ms) between calls, so 100 transactions take a minute or two. When it's rate-limited, web3.js waits and retries by itself and prints a line saying so. To read more, set RPC_URL to your own endpoint: AllenHark RPC allows 100 requests per second on the standard plan, and Dedicated RPC has no rate limits.

Red flags

• Most of its PnL is one token.
• It created the tokens it trades, or was funded by the wallet that did. In an explorer, check who created the token and where the wallet's SOL came from.
• It buys in the same block a token is created, launch after launch.
• It sells within seconds of buying.
• Its buys are big next to the pool.
• It trades many times a minute.
• It's a new wallet with a short, perfect history.
• Buying often follows its buys, and it sells into that buying.
• A list, group or seller that won't show you the wallet's full history.

How to size copies and spread them across wallets

• Start small and fixed. A fixed amount of SOL per copy keeps every copy the same size, so one bad token costs what you expected.
• Be careful with "share of their buy". If the wallet suddenly buys ten times its usual size, so do you. Cap the biggest buy of theirs you'll copy.
• Spread across several wallets, each copied small, so one bad wallet can't sink you.
• Watch for overlap. Wallets that buy the same tokens are one bet, not several. Decide what happens when a second wallet buys a token you already hold.
• Cap the total: a budget for the most SOL in open trades, a daily loss limit, the most positions at once, and the most SOL in one token.
• Don't copy dust. On a tiny copy, fees and token account rent take most of it.

When to stop copying a wallet

Set your stop rules before you start, while you're calm:

• A loss on that wallet you chose in advance, or a set number of losing copies in a row.
• Your copies do much worse than its own trades. The gap is what you lose by being later. If it's bigger than the wallet's edge, the wallet isn't one you can copy.
• Its style changes: bigger buys, faster flips, new launchpads, or a long silence and then a burst.
• It starts showing the red flags above.

In the AllenHark app, every copied trade names the wallet it copied, so you can see which wallet costs you most. Switching a wallet off keeps it on your list without copying it.

How the AllenHark Solana Wallet Copy Trader helps

The Solana Wallet Copy Trader follows the wallets you choose, copies their buys from your own bot wallet on your own server, sized by your rules, and sells by your exits. It reads their trades through its own Yellowstone gRPC connection and checks over RPC as well, to catch trades the stream missed. It detects in 0.2 ms and sends through AllenHark Relay, which lands transactions in the same block at 0.1 ms over QUIC.

That shortens the gap; it can't remove it. You still buy after the wallet you copy.

These settings match the checks above. The names are the app's; the guide and the settings reference cover each one.

The three Styles set the five entry filters like this:

Changing a filter by hand makes the Style Custom. A few more things worth knowing:

• A sell by the wallet doesn't sell your copy unless your exits include a mirror sell: sell the same share they sell, or sell everything when they sell everything. The starters include one, along with a stop loss, a take profit and a trailing stop.
• Every skip shows on the bot's page with its reason, in plain words, so you can see which filter stops which wallet's trades.
• If a filter's data can't be read (a pool's size, say), that filter is passed over and the copy goes ahead. Only the mint and freeze authority check skips the copy instead.
• Up to 200 wallets per bot, as many as your plan allows.
• Early shred detection is an optional monthly add-on. The bot also sees the wallets' trades in shreds, before they land, so it can copy sooner. A copy can then follow a trade that fails: if the bot learns that before its copy goes out, it sends none; a copy already sent stays, and your exits sell it.

Plans are monthly: see the bot's page for the current monthly price, and Plans and billing for the add-ons.

Practice mode first

A new Solana Wallet Copy Trader starts in practice. It copies the real trades of the wallets you follow with virtual SOL (10 SOL to start; the practice balance is in Advanced), and nothing is sent to the network. Fees and slippage are counted, so practice results aren't flattered.

Use practice to test wallets, not just settings:

1. Add the wallets you're considering, each with a small size.
2. Let it run long enough to see each wallet's bad days as well as its good ones.
3. Compare the wallets in your trades list, where each copy names the wallet it copied.
4. Switch off the wallets whose copies lose, then go live with the rest, small.

To look around before you deploy, the Solana Wallet Copy Trader demo runs in your browser on a simulator.

Practice is a guide, not a forecast. It counts fees and slippage, but it can't know how a live buy would have moved the price for others. Going live takes SOL in your bot wallet and your PIN, and you can go back to practice from the bot's menu at any time. The quick start walks through each step.

The risks, plainly

• Copying a wallet doesn't copy its results. You buy after it, at a price its own buy has already moved, and often after other copiers. On thin tokens that alone can turn its gain into your loss.
• Its sells can come before yours. A mirror sell starts when the bot sees their sell, so the price may already have fallen.
• Most new tokens go to zero, many within minutes of launch, and some are rugs that can't be sold at any price.
• A stop loss limits most losses, not all. A price can drop a long way between two updates.
• Fees add up on every copy, winning or losing.
• A wallet's past doesn't predict its future. A wallet that did well last month can do badly this month.

Only trade SOL you can afford to lose, and read the risk disclosure first. Limits and safety explains the budget, the daily loss limit and Pause all.

FAQ

What makes a Solana wallet worth copying?

Many closed trades over weeks, a result that doesn't hang on one token, holds long enough for a copy to get in, buys that are small next to the pool, and trades you can actually follow. Even then, your copies will do worse than the wallet, so watch it in practice first.

Where can I find profitable Solana wallets to copy?

Leaderboards and wallet trackers show wallets that did well, sorted by results. Treat them as a list to check, not a list to copy. Look each wallet up in an explorer or with the script above, drop the ones that show red flags, and watch the rest in practice before you put SOL behind them.

Why do my copies do worse than the wallet I copy?

Because you buy after it. Its own buy moves the price first, other copiers may buy before you, and you pay your own fees and slippage. On fast tokens it can be selling while your copy is still landing.

How many wallets should I copy at once?

There's no right number. Several small copies spread across wallets that trade different tokens is safer than one big bet on one wallet. The Solana Wallet Copy Trader follows up to 200 wallets per bot, as many as your plan allows.

Does the copy trader sell when the wallet sells?

Only if your exits include a mirror sell. The starters include one. Without it, your own stop loss, take profit and other exits decide when it sells.

Is copy trading on Solana profitable?

Sometimes, and often not. Nobody can promise a profit, and AllenHark doesn't. Judge each wallet by your own PnL on its copies, after every fee, and start in practice.

Related reading

• Solana Wallet Copy Trader guide: how it watches, checks, buys and sells.
• Solana Wallet Copy Trader settings: every setting with its range and starting value.
• Troubleshooting: what to check when it isn't copying.
• Managed Solana trading bot vs Telegram bots: who holds the key, and how fees work.
• Pump.fun bonding curve sniper bot: block 0 and real trading: why the earliest buyers get a price nobody else can.

Sources

Checked October 30, 2026.

• Solana docs, getSignaturesForAddress: newest first, up to 1,000 signatures per call, before to page back.
• Solana docs, getTransaction: maxSupportedTransactionVersion, jsonParsed, the fee, and the balances before and after.
• Solana docs, RPC endpoints: the public mainnet endpoint and its rate limits.
• Solana docs, fee structure: the base fee plus the priority fee, charged even when a transaction fails.
• Solana docs, wrapped SOL: the native mint addresses.
• AllenHark: the Solana Wallet Copy Trader guide, its settings reference, the risk disclosure, Limits and safety and Plans and billing.