For trading terminals · integrations

The verified signal layer for Solana memecoin terminals.

In the last 30 days, —% of mints we scored at ≥70% confidence in their first 60 seconds actually graduated. Every prediction publicly hashed before the outcome was known. Embed it in your terminal in <30 minutes.

Live receipt, last 30 days

—% of mints we scored ≥70% in their first 60 seconds graduated (—). Queryable live on /api/accuracy — not a slide, not a screenshot. The model keeps learning; the number ticks with it.

Discipline receipt: the Jun 2 verdict

74.7% of ACT calls peaked ≥5× within 24h on a 14-day pre-registered window (n=561). Acceptance criteria hashed and committed before any outcome was visible. Chain publicly verifiable on /verdict.

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 →