Build whale-tracking bots on clean Polymarket data

Track a specific whale (full profile + smart-money flag)

import requests

WALLET = "0x7f3c8979d0afa00007bae4747d5347122af05613"

# /api/v2/wallet/{addr} is a public endpoint — no API key required
r = requests.get(f"https://orcalayer.com/api/v2/wallet/{WALLET}")
data = r.json()

# Response is composed: profile / overview / stats / categories
profile = data["profile"]
stats = data["stats"]
overview = data["overview"]

print(f"Name: {profile['name'] or profile['pseudonym']}")
print(f"Total PnL: ${stats['total_pnl']:,.0f}")
print(f"Win rate: {stats['win_rate']:.1%}")
print(f"Smart Money flag: {stats['is_smart']}")
print(f"Markets traded: {overview['total_markets']}")
print(f"Median hold: {overview['median_hold_days']} days")

List hot markets with whale skew

import requests

# Markets with whale positioning (public endpoint — no key needed)
r = requests.get("https://orcalayer.com/api/v2/markets/search?limit=10")
markets = r.json()["markets"]

for m in markets:
    skew = m["whales_yes"] - m["whales_no"]
    print(
        f"{m['question'][:60]:60s} "
        f"YES={m['price_yes']:.2f}  "
        f"whales={m['whales_yes'] + m['whales_no']:4d}  "
        f"skew={skew:+d}"
    )

Poll whale trades — bot loop

import requests
import time
from collections import deque

API_KEY = "your_premium_key"   # premium /api/v2 endpoints use the X-API-Key header

# Bounded de-dup: remember the last 10k tx hashes, not every hash forever.
seen = set()
seen_order = deque(maxlen=10_000)

while True:
    try:
        r = requests.get(
            "https://orcalayer.com/api/v2/whales/recent-trades",
            headers={"X-API-Key": API_KEY},
            timeout=15,
        )
        r.raise_for_status()
        trades = r.json()
    except requests.RequestException as exc:
        print(f"request failed, retrying in 30s: {exc}")
        time.sleep(30)
        continue

    for trade in trades:
        key = trade["tx_hash"]
        if key in seen:
            continue
        if len(seen_order) == seen_order.maxlen:
            seen.discard(seen_order[0])   # evict oldest as the ring rolls over
        seen_order.append(key)
        seen.add(key)

        # Filter: $50K+ trades from named whales
        if trade["size_usd"] >= 50_000 and trade.get("whale_name"):
            print(
                f"WHALE: {trade['whale_name']} "
                f"${trade['size_usd']:,.0f} {trade['side']} "
                f"@ {trade['price']:.2f} on '{trade['question'][:50]}'"
            )
            # → forward to Discord / Telegram / Slack webhook

    time.sleep(30)  # Premium tier — well under 600 req/min budget

Live indexed trade stream — MINT/MERGE events (SSE, Premium)

# Connect with your existing Premium API key — no extra setup.
# types filter: mint, merge, complementary; omit for all classified fills.
curl -N -H "Authorization: Bearer YOUR_PREMIUM_KEY" \
  "https://orcalayer.com/api/public/v1/live/trades-indexed?types=mint,merge"

# Each event: entry_type, maker, taker, both directions, price, usd_amount, market metadata.
# The maker side of arbitrary wallets is not available from Polymarket's public API at all.
# A MINT with SELL on YES = the wallet ENTERED NO — not an exit.
# Live-only (no replay on reconnect) — keep a REST poll as fallback.
# Typical latency: 20-45s after on-chain confirmation.

Wallet screener — top sports wallets by ROI (Business)

import requests

API_KEY = "your_business_key"

r = requests.get(
    "https://orcalayer.com/api/v2/business/screener",
    headers={"X-API-Key": API_KEY},
    params={"category": "SPORTS", "active_days": 14, "min_resolved": 50,
            "min_win_rate": 58, "sort": "roi", "limit": 25},
    timeout=20,
)
r.raise_for_status()
for w in r.json()["wallets"]:
    name = w["display_name"] or w["wallet"][:10]
    print(f"#{w['rank']:>2} {name:<20} ROI {w['roi_pct']:>6}%  "
          f"WR {w['win_rate_pct']}%  PF {w['profit_factor']}  resolved {w['resolved_markets']}")

Webhooks — get whale trades pushed to you, verify the signature (Business)

# 1) Register once
import requests

API_KEY = "your_business_key"
r = requests.post(
    "https://orcalayer.com/api/v2/business/webhooks",
    headers={"X-API-Key": API_KEY},
    json={"url": "https://your.app/orcalayer-hook",
          "events": ["whale_trade", "wallet_trade"],
          "filters": {"min_usd": 5000, "categories": ["SPORTS"],
                      "wallets": ["0x2a69660046d7acc4ab204d7cc5ba78b0776cd2f7"]}},
    timeout=20,
)
r.raise_for_status()
SECRET = r.json()["secret"]   # shown only once: store it

# 2) Receive and verify the signature (Flask)
import hashlib, hmac, time
from flask import Flask, request, abort

app = Flask(__name__)

@app.post("/orcalayer-hook")
def hook():
    parts = dict(p.split("=", 1) for p in request.headers["X-OrcaLayer-Signature"].split(","))
    expected = hmac.new(SECRET.encode(), f"{parts['t']}.".encode() + request.get_data(),
                        hashlib.sha256).hexdigest()
    if not hmac.compare_digest(expected, parts["v1"]) or abs(time.time() - int(parts["t"])) > 300:
        abort(400)
    event = request.get_json()
    if event["type"] == "whale_trade":
        t, w = event["data"]["trade"], event["data"]["whale"]
        print(f"{w['name']} {t['action']} {t['side']} {t['usd_amount']:,.0f} USD @ {t['price']}")
    return "", 200

Export a wallet's full trade history to CSV (Business)

import time
import requests

API_KEY = "your_business_key"
wallet = "0x2a69660046d7acc4ab204d7cc5ba78b0776cd2f7"
since = int(time.time()) - 30 * 86400   # last 30 days

with requests.get(
    f"https://orcalayer.com/api/v2/business/export/wallet/{wallet}/trades.csv",
    headers={"X-API-Key": API_KEY}, params={"since": since}, stream=True, timeout=300,
) as r, open(f"{wallet}.csv", "wb") as f:
    r.raise_for_status()
    for chunk in r.iter_content(1 << 16):
        f.write(chunk)

# A file that reaches the 500k-row cap ends with "# truncated ... continue with since=<ts>":
# call again with that since and dedupe the boundary rows by tx_hash.