launchtape

Python access to Launch Tape: daily files of Solana launch data, one file per dataset per UTC day, as gzipped JSON lines (.jsonl.gz) and as Parquet (.parquet, the same rows as typed columns).

Every file comes with a SHA-256; launchtape downloads a day you bought (fetch), checks it and reads it. The free files on the site (the graduates CSV and one coin's trades, launchtape.io/#sample) are plain CSV / JSON lines you can open without it; lt.sample(dataset) only works while the site lists a free sample of that dataset (none since Oct 14 2026), so a full day ($10, launchtape.io/?plan=day1#buy) is the way in.

Install

pip install launchtape              # needs only requests
pip install "launchtape[pandas]"    # adds pandas for launchtape.frame()
pip install "launchtape[parquet]"   # adds pyarrow, to read the Parquet files

Python 3.9 or newer.

Quickstart

Share of pump.fun graduates that touched -80% in their first 10 minutes, split by "instant" launches (graduated within 5 s of creation):

import launchtape as lt

path = lt.fetch(link, "pregrad", "2026-10-12")                 # from your download link, SHA-256 checked, cached
rec = lt.frame(path, types="record")[["mint", "sym", "instant", "ageS"]]
out = lt.frame(path, types="outcome")[["mint", "minDrop", "maxGain", "crashed"]]
out = out.dropna(subset=["minDrop"])                           # no pool trades = no prices
df = rec.merge(out, on="mint")                                 # one row per graduate seen in both
df["touched_minus80"] = df["minDrop"] <= -80                   # vs the price 10 s after graduation
print(df.groupby("instant")["touched_minus80"].agg(["mean", "count"]))
print(lt.schema("pregrad"))                                    # every row type and field

crashed is a different, milder flag: a trade at 60% of the running high or lower in the first 10 minutes (a 40%+ fall from the high), not an 80% drop. The sample is two hours, so the counts are small: it shows the shape of the data, not a result.

API

for row in lt.load("gradtrades", types="grad", limit=5):      # streams, so a 5-million-row day is fine
    print(row["mint"], row["capSol"])

path = lt.fetch("https://launchtape.io/dl/<token>", "pregrad", "2026-10-11", dest="data/")
pq = lt.fetch("https://launchtape.io/dl/<token>", "gradtrades", "2026-10-11", dest="data/", format="parquet")

Parquet

Every day file and sample also comes as Parquet: the same rows, checked against the .jsonl.gz before it ships, as one table whose columns are every field of every row type (null where a row does not have the field). t stays integer milliseconds, nested objects are structs and arrays lists, padfeed's usd is a map keyed by quote mint, and pregrad's curve, src and cross (text in some row types, an object or a number in others) are text columns, an object or number as its JSON text. Read it with pandas directly, or through lt.load / lt.frame (needs pyarrow):

import pandas as pd
df = pd.read_parquet(lt.sample("pregrad", format="parquet"))   # loads in a fraction of the JSON time
cols = ["type", "bt", "mint", "side", "user", "quoteAmount"]
trades = pd.read_parquet("data/gradtrades-2026-10-11.parquet", columns=cols)   # only the columns you need

Times: t is milliseconds since 1970 UTC (pd.to_datetime(df["t"], unit="ms", utc=True)). Coverage gaps are rows in the files (down, up, resume, end), never filled in: see each schema.

A full gradtrades day is about 5 million rows; for a DataFrame, pass types= and/or limit=, or stream with load(). A download that does not match its SHA-256 raises launchtape.ChecksumError and is not kept. Environment: LAUNCHTAPE_CACHE changes the cache folder.

Command line

launchtape datasets
launchtape head data/gradtrades-2026-10-11.jsonl.gz -n 5      # first rows of a file, as JSON lines
launchtape head data/pregrad-2026-10-11.jsonl.gz -t record -n 2   # only rows of one type
launchtape sample pregrad                     # a dataset's free sample, when the site lists one (none since Oct 14 2026)
launchtape schema pregrad
launchtape fetch https://launchtape.io/dl/<token> pregrad 2026-10-11 -o data/
launchtape fetch https://launchtape.io/dl/<token> pregrad 2026-10-11 -o data/ --format parquet

python -m launchtape ... works too.

Test your bot's rules

launchtape backtest replays simple rules on every pump.fun graduate in a gradtrades file, coin by coin, and prints a report: coins traded, win rate, median and mean return a trade, total, the worst trades, how many coins never reached your entry, what the first 10 minutes did, a plain verdict, and the same rules filled the naive way for comparison. It is the same replay as the prompt on launchtape.io/test, for when your AI can't run code.

launchtape backtest --gradtrades data/gradtrades-2026-10-11.jsonl.gz   # the example rules on a day you bought
launchtape backtest --template > rules.json          # the rules as a file to edit
launchtape backtest --rules rules.json
launchtape backtest --rules rules.json --gradtrades data/gradtrades-2026-10-11.jsonl.gz   # your rules
launchtape backtest --rules rules.json --json        # every trade, as JSON

A paid day finds its pregrad file next to it (pregrad-2026-10-11.jsonl.gz or .parquet), or pass --pregrad. A full day (about 5 million rows) takes under a minute and little memory: the file is streamed once.

How a trade is filled, so the test is never kinder than the market:

• Prices are read at the end of each slot (the slot's last trade's priceAfter and poolBase). Several trades in one slot can be one bundle, such as a big dump and its re-buy in the same block, and nobody outside could trade between them.
• A signal never fills at its own price: it fills at the end of the first slot after it. Stops and take-profits are checked at each slot's end and fill at the next one, so a -20% stop in a dump can fill at -80%.
• Every buy and sell pays 1% PumpSwap fee + 0.5% priority fee and slippage (change them in the rules), and your size moves the price: a fill uses that slot's pool (constant product, with PumpSwap's virtual SOL).
• Still holding at +30 minutes (the end of the recorded window): out at the last price. A trade still open when the file ends or the recorder stopped following the coin is left out and counted, never guessed. Feed gaps are flagged.

import launchtape as lt
res = lt.backtest({"entry_s": 15, "exit_s": 180, "stop_pct": 20, "max_fill_s": 5})
print(lt.backtest_report(res))
print(res["summary"]["medianReturnPct"], len(res["trades"]))

Full days: prices and how to buy

• One day, $10 once: any UTC day you pick (from October 4 2026): that day's gradtrades and pregrad, the test prompt with its file names, and what the example rules returned that day: https://launchtape.io/?plan=day1#buy.
• Starter, $10 a month: all 7 datasets, each new day's files as the UTC day closes, plus the last 7 days on file.
• Full history, $49 a month: everything in Starter, plus every day on file back to October 3 2026.

Buy at launchtape.io: pick one day or a plan, enter your email, press Pay (USDC or SOL on Solana; your wallet opens with everything filled in). The private download link (https://launchtape.io/dl/<token>) arrives by email, and launchtape fetch reads it.

Licences

• This package (the code): MIT, see LICENSE.
• The data it downloads, the free samples included, has its own licence: personal and research use inside your own team. No resale, republishing or redistribution of the files, in whole or in part. Results you derive from it (charts, papers, models, strategies) are yours. Full text: launchtape.io.

The data is market data recorded from public sources, provided as is. It is not financial advice.