For trading terminals · integrations

Catch pump.fun graduations before the curve completes.

Median —s of runway between our ≥0.70 call and the bonding curve completing. Built for sniper bots, fast traders, and terminals embedding a graduation-aware feed. Embed in <30 minutes.

Live timing edge

—s median between our ≥0.70 alert and the curve completing (— grads). Queryable live on /api/accuracy — not a slide, not a screenshot. Bot-actionable in real time.

Calibrated accuracy

—% of those ≥0.70 calls actually graduate within 24h (—). When the model says ≥0.90, reality lands close to 99%. We underpromise; the data shows it.

The data moat

950,000+ pump.fun mints indexed and growing — the largest verified on-chain corpus for memecoin graduation prediction. Every prediction publicly hashed before the outcome was known. The receipts chain is the moat your competition can't add overnight.

Built for embedding

REST, WebSocket, and webhook delivery. Cursor-paginated for zero-miss / zero-dupe consumption. Wallet-redaction safe (no addresses in the payload). 1-3 second poll target.

A claim only we can make

Your "powered by" credit links to a real, verifiable, on-chain-anchored receipts chain. Trust as a feature — and your competition can't add it overnight.

Integration paths

Pick the surface that fits your stack. All three deliver the same signal event with the same payload shape.

Surface	Best for	Endpoint
REST poll (cursor)	Simple integrations, batch consumers	`GET /api/v1/signals?since={cursor}`
WebSocket firehose	Low-latency execution paths, live dashboards	`WSS /api/v1/ws?api_key=…`
Webhook push	Event-driven backends, "fire on signal"	`POST /api/v1/webhooks/register`

Signal payload

Each signal event is the same machine-readable shape across REST, WebSocket, and webhook deliveries.

{
  "mint": string, // pump.fun mint address
  "tier": "ACT" | "WATCH" | "SCOUT", // conviction tier
  "composite_score": number,
  "threshold_at_cross": number,
  "score_ratio": number, // how far over threshold
  "smart_money_in": integer, // smart wallets accumulating
  "max_mult_at_cross": number,
  "age_s_at_cross": integer, // mint age in seconds
  "mc_at_cross_usd": number,
  "cross_at": unix_ts,
  "delivered_at": unix_ts // use as cursor
}

Quickstart

Live ACT/WATCH signals in 30 seconds. Replace YOUR_API_KEY with a Pro-tier key.

# Poll signal stream every 2s, dedupe via cursor
CURSOR=0
while true; do
  RESP=$(curl -s "https://graduate-oracle.fly.dev/api/v1/signals?since=$CURSOR&tier=ACT" \
    -H "X-API-Key: YOUR_API_KEY")
  echo "$RESP" | jq -c '.signals[]'
  CURSOR=$(echo "$RESP" | jq -r '.cursor')
  sleep 2
done

import requests, time

API   = "https://graduate-oracle.fly.dev/api/v1/signals"
HDR   = {"X-API-Key": "YOUR_API_KEY"}
cursor = 0
while True:
    r = requests.get(API, headers=HDR,
                     params={"since": cursor, "tier": "ACT"}).json()
    for sig in r["signals"]:
        # sig["mint"], sig["tier"], sig["composite_score"], ...
        handle_signal(sig)
    cursor = r["cursor"]
    time.sleep(2)

const API = "https://graduate-oracle.fly.dev/api/v1/signals";
const HDR = { "X-API-Key": "YOUR_API_KEY" };
let cursor = 0;

setInterval(async () => {
  const r = await (await fetch(
    `${API}?since=${cursor}&tier=ACT`, { headers: HDR })).json();
  r.signals.forEach(handleSignal);
  cursor = r.cursor;
}, 2000);

use reqwest::Client;
use serde::Deserialize;

// payload shape — see above for full field set
#[derive(Deserialize)]
struct Resp { signals: Vec<Signal>, cursor: i64 }

async fn poll(c: &Client, mut cursor: i64) {
    loop {
        let r: Resp = c.get("https://graduate-oracle.fly.dev/api/v1/signals")
            .header("X-API-Key", "YOUR_API_KEY")
            .query(&[("since", cursor), ("tier", "ACT")])
            .send().await.unwrap().json().await.unwrap();
        for s in r.signals { handle(s); }
        cursor = r.cursor;
        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    }
}

Token alignment

The economics of our integration are designed to align you, not bill you.

$GO — two ways in

💎 Subscribe in SOL. Pay monthly via Phantom. Founding rate locked permanently — your price never goes up.

🪙 Or hold $GO. Hold the tokens in a linked wallet, auto-upgrade to the matching tier. Sell → drops back to your paid tier. No double-charging.

Two thresholds:
→ 500,000 $GO → TG bot composite signal
→ 2,500,000 $GO → API access (Builder tier)

Pro / Enterprise (webhooks, WebSocket firehose, white-label) stay subscription-only — high-end B2B, paid in SOL.

On-chain tokenomics happen at the trade layer, not the app layer: 50% burn · 30% SOL to holders · 10% public site treasury, every trade, sealed by the Proof Launch bot contracts. Holders win on appreciation AND on deflationary supply pressure.

The 30-day pilot

Send one DM. We'll spin up a free Pro-tier API key for 30 days, walk you through integration, and ship a "powered by graduate-oracle" visual asset for your UI.

DM @GraduateOracle on X → Full API docs →