Launch Tape

Free ChatGPT · Claude · Cursor · no API key

Test your bot on what actually happened.

You built a Solana memecoin bot with AI. Before it trades real SOL, replay its rules on real pump.fun graduations, coin by coin, with the fills and fees a real bot gets. Copy one prompt, paste it into your AI with your rules, read the report.

Copy the prompt See an example report

01

Three steps

About five minutes

  1. Copy the prompt

    One block of plain English, below. It tells your AI what the data is (one full UTC day, $10; or the free graduates CSV for a first look) and how to test without fooling you.

  2. Paste it with your rules

    Into ChatGPT, Claude or Cursor. Replace the [brackets] with your bot's rules: when it buys, when it sells, how much, which coins it skips.

  3. Read the report

    Coins traded, win rate, median and mean return, total after fees, the worst trades, and a plain verdict, from a full day of real graduations.

Your AI has to run Python. Cursor, Claude Code and your own terminal can. ChatGPT's sandbox can't download files: give it the day's two files (gradtrades and pregrad, from your One day download link, $10) with the prompt. For a first look, the free graduates CSV (105 coins, 19 KB) shows what each coin did; a replay needs the day's trades.

Start here fits in ChatGPT/Claude

Want the whole picture? Test on a full day: $10. Every graduate of one UTC day, every trade in its first 30 minutes, and who was behind each launch, as JSON lines and Parquet, with this prompt filled in with that day's file names.

No AI at hand? The same test runs in a terminal: pip install launchtape, then launchtape backtest --gradtrades gradtrades-<day>.jsonl.gz for the example rules on your day file, or launchtape backtest --template > rules.json, edit it, and add --rules rules.json for yours.

02

The prompt

2,846 characters · plain English

Paste this into your AI

edit the [brackets] 
Test my Solana memecoin bot's rules on real pump.fun data: write and run one Python script. No API keys needed.

DATA
Files: gradtrades-<day>.jsonl.gz and pregrad-<day>.jsonl.gz, one full UTC day (Launch Tape One day, $10). Run: pip install launchtape; launchtape.load(path) yields dicts. No internet? Ask me for the two files.
- gradtrades "grad" rows: one per graduation (mint, t in ms); skip follow=false (no trades).
- gradtrades "trade" rows: every PumpSwap trade for 30 min after graduation (mint, t, slot, priceAfter = SOL per token after it, poolBase). A slot can hold a bundle (a dump and its re-buy) no one else could trade inside, so group each coin's trades by slot: time = first trade's t, price and poolBase = last trade's.
- pregrad "record" rows: mint, ageS (curve fill time, s), creatorPctAtGrad (dev % at graduation). "outcome" rows: mint, minDrop and maxGain (worst and best %, first 10 min).

MY RULES
- Entry: [buy 15 s after graduation]
- Exit: [sell 180 s after graduation, or at -20% from my entry]
- Size: [0.1 SOL a trade]
- Filters: [none]

REPLAY each graduate on its own slots:
1. Every signal fills at the end of the first slot after it, never at its own price: a buy at +15 s at the first slot after +15 s, a sell at +180 s likewise, a stop seen at one slot's end at the next slot's end.
2. Costs per side: 1% PumpSwap fee + 0.5% priority fee and slippage.
3. Size moves the price. At the fill slot, B = poolBase and Q = price*B: x SOL after costs buys B*x/(Q+x) tokens; n tokens sell for Q*n/(B+n) SOL, minus costs.
4. Check stops and take-profits at each slot's end vs the entry fill price.
5. Still holding at +30 min: sell at the last price before it. File ends while a trade is open: leave that coin out.
6. No slot after my entry signal: that coin never reached the entry.

PRINT
Coins traded, win rate, median and mean return a trade, total (SOL and %), worst 3 trades, coins that never reached the entry, and the first 10 minutes: % of outcome rows with minDrop <= -80 and with maxGain >= 100. Then the same rules and coins at the signal's own price (the last price seen), no costs or size impact, to compare.

Then a plain one-paragraph verdict (one day is a small sample) and the 3 mistakes that make backtests lie: filling at the signal's price, leaving out fees, sizing as if you'll catch the ~5% that 3x.
Only the free graduates CSV (no trades)? Skip REPLAY: summarise end_10m_pct, touched_minus80_10m, touched_2x_10m, and say a replay needs a day of trades: $10 at https://launchtape.io/?plan=day1#buy

Can't run code? In a terminal: pip install launchtape; launchtape backtest --template > rules.json; edit it; launchtape backtest --rules rules.json

After answering, tell me plainly: this is 105 coins over 2 hours, too small to judge a rule. A full UTC day is ~700-800 graduates: launchtape.io/#buy

It fills you a block late

Your bot sees a price, then its transaction lands in a later block. So every buy and sell fills at the end of the next block after the signal, never at the price that triggered it.

It reads prices at block ends

Some "dumps" are bought back inside the same block: in our sample, 14 dips of 46% to 75% on two coins, each re-bought before its block ended, often for almost exactly the SOL that was sold. Those prices existed only between transactions inside one block. No bot watching could trade at them, so the test doesn't either.

It charges you

1% PumpSwap fee plus 0.5% for priority fee and slippage, on the way in and on the way out: about 3% a round trip. PumpSwap's own fee on the example's fills averaged 1.04%.

It never guesses

Your size moves the price, from the pool's real reserves. A trade still open when the data ends is left out and counted. Stops fill where the market was, not where you set them.

03

What you'll see

Real numbers, run on 2 hours of October 10 2026 (14:00-16:00 UTC)

We ran the prompt's example rules on 2 hours of October 10 (the free sample at the time): buy 15 seconds after graduation, sell at 3 minutes or at -20%, 0.1 SOL a trade. Here is what came back.

The usual backtest +2.3% a trade

The same rules filled at the price that triggered them, with no fees: 56.7% of trades win and the average trade makes money. That's the test most AI-written bots pass.

The honest replay -0.9% a trade

Fills a block late, fees and slippage both ways, your size against the real pool: 50.7% win. Stops set at -20% filled at -23.9% (median). The worst trade, Odyssey, lost 82.7%: one sell took its pool from 248 to 87 SOL in a single block, and the stop could only fill after it.

Bar chart. The same rules, buy 15 seconds after a pump.fun graduation, sell at 3 minutes or -20%, 0.1 SOL a trade, on 67 coins on Oct 10 2026 14:00-16:00 UTC: the usual backtest (signal's price, no fees) shows +2.3% a trade; the same rules on the tape (fees, next-block fill, size moves the pool) -0.9%. A full day, Oct 12 2026, 775 coins: -3.9% a trade.
LAUNCH TAPE BACKTEST: your rules on what actually happened

Data     gradtrades-2026-10-10-1400-1600utc.jsonl.gz
         2026-10-10 14:00 to 15:59 UTC (2 h)

Rules
  entry    buy 15 s after graduation
  exit     sell 3 min after graduation, stop -20%, no take-profit
  size     0.1 SOL a trade
  filters  none
  costs    1% PumpSwap fee + 0.5% priority/slippage, each side
  fills    at the end of the first slot after each signal, never at the
           signal's own price; your size moves the pool price too

Coins
  graduations in the file             105
  no trades recorded (not followed)    36
  never reached your entry              0
  file ended before the trade did       2   (left out)
  coins traded                         67

Results, after costs
  win rate                   50.7%   (34 of 67)
  median return a trade      +0.3%
  mean return a trade        -0.9%
  total                     -0.063 SOL on 6.7 SOL put in (-0.9%)
  exits                   41 on time, 26 stop
  stops filled at           -23.9%   median price move, stop set at -20%
  real PumpSwap fee          1.04%   on these fill trades (assumed 1%)
  worst 3 trades
    Odyssey        -82.7%   in at +16.5 s, out at +178.9 s (stop)
    GQ8ufQ...      -36.4%   in at +15 s, out at +39.3 s (stop)
    7EyXui...      -35.6%   in at +15.4 s, out at +90.5 s (stop)
  best trade  BUBUN         +168.2%

The same rules at the signal's own price, no costs or size impact
  median +3.5%, mean +2.3%, win rate 56.7%  <- what a naive backtest shows

What the first 10 minutes did (67 graduates with an outcome row)
  touched -80%               34.3%   (vs the price 10 s after graduation)
  touched 2x                 10.4%
  touched 3x                  3.0%
  first big dump              2.9 min   median after graduation (26 coins had one)

Verdict
  On this data your rules lost 0.063 SOL over 67 trades (-0.9% of what went
  in), after costs. The typical trade won a little, but the losers were
  bigger than the winners. Filled the naive way (the signal's own price, no
  costs) the same rules look 3.2 points better per trade on average: that
  gap is money a backtest promises and the market does not pay. 67 trades
  from 2 hours of data is a small sample: one coin can swing these numbers.
  Run it on full days before you risk real money.

2 hours, 67 trades. A full day of the same rules is one file: $10 at https://launchtape.io/?plan=day1#buy

The 3 mistakes we see most
  1. Filling at the signal's own price. Your bot sees a price, then sends a
     transaction that lands in a later block, and in a dump later is lower.
     Here it evened out on average (+2.3% vs +2.3% before costs), but not on
     stops: set at -20%, they filled at -23.9% (median), the worst at
     -82.1%.
  2. Leaving out fees. 1% PumpSwap fee + 0.5% priority/slippage each side is
     about 3.0% of every round trip; here costs took the median trade from
     +3.5% to +0.3%.
  3. Sizing as if you'll catch the few that 3x. Only 3.0% of these graduates
     touched 3x in their first 10 minutes, and 34.3% touched -80%. Size
     every trade as if it's one of the losers, because most are.

This is the text launchtape backtest prints; your AI writes its own version of it. On a full day (Oct 12 2026, 775 coins traded) the same rules returned -3.9% a trade on average (median -1.2%, 47.6% won). Two hours is a taste; a day is a test.

04

The mistakes we see most

From 2,193 graduates, Oct 10-12 2026 UTC
62.9%

Treating graduation as the finish line

62.9% of graduates fell 40% or more from a high inside their first 10 minutes, and 38.1% touched -80%. Only 15.0% touched 2x and 5.3% touched 3x. Size every trade as if it's one of the losers.

2.2 min

Testing slower than the market moves

When a big holder dumped, the median was 2.2 minutes after graduation (894 coins had a sale that tripped our dump rule; 48% came inside 2 minutes). A bot that checks every 30 seconds has already spent a quarter of that.

3%

Fills at the signal's price, and no fees

About 3% of every round trip goes to fees, priority and slippage. On Oct 12, it took the example rules' median trade from +2.0% to -1.2%. And a -20% stop is not a -20% fill: the worst filled at -96.5%.

50% vs 86%

Trusting a filter you never checked

"Fast fill = bundle = rug" is a common rule. Curves that filled within 5 seconds fell 40%+ from a high 50% of the time, slower ones 86% (1,384 and 803 graduates). Yet both touched -80% about as often (38.4% vs 37.6%), and slow fills touched 2x three times as often (26.3% vs 8.5%). Test a filter against the outcome you trade on.

How we measure, from the pregrad outcome rows: -80%, 2x and 3x are minDrop and maxGain, from the price 10 seconds after graduation, within the first 10 minutes. "Fell 40% or more from a high" is the crashed flag: a trade at 60% of the running high or lower. The dump time is dump.tS. "Filled within 5 seconds" is the record's instant. Graduates with no pool trades have no prices and are left out.

05

Go further

One day $10 · One week $20

Two hours is a taste. A day is a test.

The example above is 2 hours. A full day is every pump.fun graduation of that UTC day (1,179 on Oct 12), every trade in the first 30 minutes of each one we follow (786 that day), and who was behind each launch. Point the same prompt, or launchtape backtest --gradtrades, at a day file. One day is $10, once; the free graduates CSV shows what the day sheet looks like.

One week is $20, once: the last 7 days, every dataset. Full history is $49 a month: every day since Oct 3, then a new one each morning.

See the plans Test on a full day $10, once

Market data, not financial advice. A backtest shows what your rules would have done on these coins; it can't promise what they'll do next.