cookin-fun 0.1.0

Python SDK for the Cookin API — Pump.fun and Solana memecoin data (REST + WebSocket).

cookin-fun

Python SDK for the Cookin API — real-time Pump.fun and Solana memecoin data. REST + WebSocket over the same pipeline that powers the cookin.fun UI. Quality scores, bundle detection, trader behavioral stats, live trade frames.

• Free during beta. No credit card.
• Docs: https://cookin.fun/api
• Discord: https://cookin.fun/discord

Install

pip install cookin-fun

Python 3.9+.

Quickstart

Mint an API key at cookin.fun/account/api-keys and set it as COOKIN_API_KEY.

from cookin_fun import Cookin
import os

cookin = Cookin(api_key=os.environ["COOKIN_API_KEY"])

# Full snapshot for one token
snap = cookin.tokens.get("BgNrWZKAaZAa...")
print(snap["data"]["score"]["value"], snap["data"]["holders"]["count"])

That's it. Every REST method returns the raw envelope dict {"data": ..., "meta": ...}. TypedDict definitions ship with the package so IDEs get autocomplete for every field.

REST

Every REST method returns the envelope as a plain dict. Field types are documented via TypedDicts in cookin_fun.types.

# Token feeds. All four return a list of token cards.
cookin.tokens.new()          # recently deployed
cookin.tokens.pumps()        # currently pumping
cookin.tokens.graduated()    # recently on Raydium / PumpSwap
cookin.tokens.survivors()    # 3-24h post deploy, still alive

# One token, one call. Filter to the field groups you actually need.
cookin.tokens.get(mint, fields=["meta", "market", "score"])

# Most recent trades for a token, enriched with per-trade trader context.
cookin.tokens.trades(mint)

# Full behavioral profile for a wallet.
cookin.traders.get(wallet_address)

WebSocket

Two channels, both multiplexed on one socket connection. Use .on_tokens / .on_frames to register handlers, then .run_forever() to pump events.

socket = cookin.connect()

# Token lifecycle events: created, graduated, DEX-paid, metadata,
# duplication flags flipped.
def on_token_event(event):
    if event["type"] == "token_created":
        card = event["data"]
        print("new token:", card["symbol"], card["score"])

# Every enriched trade, ~1s off Solana block time. One message per
# {signature, mint} unit, so multi-hop swaps arrive grouped.
def on_frame(frame):
    for trade in frame["trades"]:
        print(trade["signature"], trade["user_address"], trade["sol_amount"])

with socket:
    socket.on_tokens(on_token_event)
    socket.on_frames(on_frame)
    socket.run_forever()

The SDK handles the Phoenix Channels v2 wire protocol (join, heartbeat, event dispatch) internally. Reconnect and back-pressure are left to callers on purpose so the SDK stays predictable. Wrap .connect() in your own reconnect loop for long-lived processes.

Examples

Two runnable scripts in examples/:

• lifecycle_events.py — subscribes to tokens:live and prints one line per event type (token_created, token_metadata_retrieved, token_graduated, token_dex_paid, token_duplication_status_updated).
• wallet_watcher.py — streams frames:live filtered to a list of wallets.

COOKIN_API_KEY=sk_live_... python examples/lifecycle_events.py

Errors

Non-2xx responses raise a typed CookinError:

from cookin_fun import CookinError

try:
    cookin.tokens.get(mint)
except CookinError as exc:
    print(exc.status, exc.code, exc.request_id)

Every response carries a request_id in meta (and on errors, on the exception). Quote it when reporting issues.

Rate limits

60 requests per minute per key. X-RateLimit-* headers on every response. See Rate limits for details.

Full reference

Every endpoint, every field, every WebSocket event: cookin.fun/api.

• Token snapshot fields
• tokens:live event schema
• frames:live schema
• Supported DEXes

Contributing

Bug reports and feature requests: Discord.

License

MIT