Signal Infrastructure · Polymarket Native

Your strategy deserves
real alpha.

A paper trading sandbox priced at live CLOB quotes. Oracle lag, order-book imbalance, and weather EV signals — live-tested in production, available per API call.

Create Sandbox Free → Documentation API Reference
Any AI
REST / OpenAPI
Full OpenAPI spec. Import into any HTTP-capable agent.
API docs →
sunflower · mcp tool call
$
RTT to Polymarket CLOB
Oracle lag win rate (live)
Proprietary CLOB tape
Per signal call (USDC)
Built for three different minds

One API.
Three entry points.

Whether you're an autonomous agent, a quant validating a thesis, or a trader who wants an edge — the sandbox meets you where you are.

AI Agent / LLM

Five tool calls to a running strategy.

MCP-native from day one. Create a sandbox, fire signals, execute simulated trades, and read a performance report — all from inside your Claude or GPT conversation. No browser, no wallet, no setup.

  • FastMCP tools: sandbox_create, sandbox_buy, sandbox_signal, sandbox_report
  • OpenAPI spec at /openapi.json — import as a ChatGPT Action in 60 seconds
  • Credit billing by wallet address — x402-compatible, agent-autonomous
  • Signal responses ≤80 tokens — no context drain
  • Degrades gracefully when engines are offline
Quant / Researcher

Real tape. Not simulated. Not synthetic.

721MB of raw CLOB ticks from the live Polymarket order book. One labeled event dataset per strategy — oracle lag, PMIMB, weather EV — with 20+ features and settlement outcomes. Run your own gate logic against our tape in SQL or Python.

  • CSV/Parquet exports — pd.read_csv() ready
  • Bootstrap CI on win rate, binomial p-values, Sharpe t-stat
  • ACF, event study (T=[-60,+300]s), factor regression
  • Custom gate backtester: define entry filter, simulate P&L
  • Full performance report with statistical annotation for builder applications
Trader / Human Builder

Live signals, tested in production.

Oracle lag, order-book imbalance, and weather EV — all running live on our infrastructure today. Subscribe via REST or MCP. One credit per query. Our engines have been running these signals for months before we opened the API.

  • Oracle lag signals for BTC, ETH, SOL, XRP — live-tested
  • Order-book imbalance signals across 4 assets
  • Weather EV signals for 12 cities worldwide
  • WebSocket portfolio stream: fills, settlements, price ticks
  • Promote validated paper strategies via Polymarket Builder Program
The signal layer

Three edges.
All live-tested.

Every signal runs on our live infrastructure before it's available via API. We are the first customer.

Oracle Lag LIVE
79%
Win Rate · BTC 5m · n=200+

Prediction markets are slow to reprice when new price information arrives. Our engine detects the window between when data changes and when markets catch up — and positions on the right side of that gap.

BTC · ETH · SOL · XRP 5m · 15m windows Calibrated entry gate Multi-signal confirmation
PMIMB LIVE
+10%
EV per window · BTC · 4-day tape

Order book composition at market open reveals directional bias before prices move. Structural imbalances in buy-side vs sell-side depth consistently predict where prices will settle.

Order-book imbalance Oracle-independent Standalone signal 4-asset consensus mode
Weather EV PAPER
64%
Backfill ROI · Class A signals

Our model is calibrated directly against Polymarket settlement outcomes — not generic weather data. Real-time observational data overrides forecast models for same-day markets.

12 fitted cities Settlement-calibrated model Real-time data override Half-Kelly sizing
Quick start

Running in 60 seconds.

Choose your entry point.

# Add to your Claude/GPT MCP config:
{
  "mcpServers": {
    "sunflower": {
      "command": "uvx",
      "args": ["sunflower-mcp"],
      "env": { "SUNFLOWER_API": "https://api.polysandbox.trade" }
    }
  }
}

# Then in conversation — the agent does the rest:
sandbox_create(label="my-first-strategy", initial_usdc=1000)
# → { "sandbox_id": "sb_abc123", "usdc_balance": 1000.0 }

sandbox_signal(signal_type="oracle_lag", asset="btc",
               wallet_address="0xYour…")
# → { "signal_active": true, "direction": "dn", "confidence": 0.81,
#     "oracle_gap_usd": 42.5, "ask": 0.63, "kelly_fraction": 0.18 }

sandbox_buy(sandbox_id="sb_abc123", token_id="0x…",
            amount_usdc=50, label="oracle_lag_btc")
# → { "fill_price": 0.630, "shares": 79.36, "fee_usdc": 0.05 }

sandbox_report(sandbox_id="sb_abc123")
# → { "total_pnl": 12.48, "win_rate": 0.78, "n_resolved": 9 }
import requests, pandas as pd

# 1. Create a sandbox
sb = requests.post("https://api.polysandbox.trade/v1/sandbox",
    json={"label": "quant-test", "initial_usdc": 5000}).json()
sid = sb["sandbox_id"]

# 2. Pull oracle lag event tape (labeled CSV)
tape = pd.read_csv(
    f"https://api.polysandbox.trade/v1/data/tape/oracle_lag_btc",
    headers={"X-Wallet": "0xYour…"}
)
# tape: timestamp, oracle_gap_usd, confidence, direction, outcome_pnl, ...

# 3. Custom gate backtest
filtered = tape[(tape["oracle_gap_usd"] > 40) &
                (tape["confidence"]   > 0.82)]
wr = (filtered["outcome_pnl"] > 0).mean()
ev = filtered["outcome_pnl"].mean()
print(f"WR={wr:.1%}  EV={ev:.4f}  n={len(filtered)}")

# 4. Bootstrap CI
replay = requests.post(
    f"https://api.polysandbox.trade/v1/sandbox/{sid}/replay",
    json={"strategy_type": "oracle_lag", "asset": "btc",
          "min_delta": 40, "budget_per_trade": 5},
    headers={"X-Wallet": "0xYour…"}
).json()
print(replay["report"])  # wr, ev, ci_95, sharpe, n_resolved
# 1. Check live signal (1 credit = $0.001)
$ curl -H "X-Wallet: 0xYour…" \
  https://api.polysandbox.trade/v1/signals/oracle_lag/btc

# → {
#     "signal_active": true,
#     "direction": "dn",
#     "confidence": 0.812,
#     "oracle_gap_usd": 42.5,
#     "ask": 0.630,
#     "kelly_fraction": 0.18,
#     "question": "Will BTC close down on this window?"
#   }

# 2. Top up credits (1 USDC = 1,000 signal calls)
$ curl -X POST https://api.polysandbox.trade/v1/credits/mint \
  -H "Content-Type: application/json" \
  -d '{"wallet":"0xYour…","usdc":1.0}'

# 3. Stream your sandbox portfolio (WebSocket)
$ wscat -c wss://api.polysandbox.trade/v1/stream/sb_abc123
# ← { "type": "price_update", "bid": 0.631, "ask": 0.634 }
# ← { "type": "settlement",   "outcome": "dn", "pnl": 2.94 }
Pricing

Start free.
Pay for alpha.

The sandbox is always free. Signals cost one credit per query. Credits never expire.

For Everyone
Sandbox
$0 forever
No wallet required. No credit card.
  • Paper sandbox with $10,000 demo USDC
  • Fills priced at live CLOB quotes
  • GTC + FAK order simulation with fees
  • Portfolio analytics & leaderboard
  • WebSocket portfolio stream
  • Strategy replay (backtest)
  • MCP tool access (all non-signal tools)
  • Live signals (credits required)
Create Sandbox Free →
Professional
Pro Signals
$200 / month
Send exactly $200 USDC on Polygon — activates automatically.
  • Everything in Signal Credits
  • Unlimited signal queries
  • 10s cache refresh (vs 60s pay-per-use)
  • WebSocket push to sandbox stream
  • Auto-trade subscriptions (set & forget)
  • All 3 signal types bundled
  • Priority signal delivery
  • 30-day rolling renewal
Activate Pro →
Quants & Research
Data Access
contact us
Raw tape exports. Custom event datasets.
  • Everything in Pro
  • 721MB raw CLOB tick data (parquet)
  • Labeled oracle lag event dataset
  • Bootstrap CI & significance testing
  • ACF, event study, factor regression
  • Custom gate backtester (SQL/Python)
  • Builder program performance report
  • Priority support
Contact →
Ready to build

Paper first.
Live when it's real.

Every signal runs in paper mode until win rate and sample size clear the bar. That's how our own engines get promoted to live. Same bar, same discipline.

Create Sandbox → Documentation Polymarket Builders ↗
Claude · MCP Server

Add Sunflower to Claude Desktop or CLI

Claude Desktop and Claude Code support local MCP servers via uvx. Paste the config below and all 9 tools are immediately available in your conversation.

claude_desktop_config.json
{
  "mcpServers": {
    "sunflower": {
      "command": "uvx",
      "args": ["sunflower-mcp"],
      "env": {
        "SUNFLOWER_API": "https://api.polysandbox.trade"
      }
    }
  }
}
Claude Desktop ↗ Claude Code ↗
Available tools: sandbox_create · sandbox_buy · sandbox_sell · sandbox_signal · sandbox_report + 4 more
ChatGPT · Custom GPT

Sunflower GPT — launching soon

The Sunflower Custom GPT opens inside ChatGPT with all 9 trading tools pre-wired via OpenAPI Actions — no setup, no copy-paste. We're publishing it now.

In the meantime — add it yourself (60 seconds)
1. Open chatgpt.com/gpts/editor ↗
2. Name: Sunflower Trading Sandbox
3. Actions → Import from URL → paste spec URL below
4. Save & publish → share link with anyone
https://api.polysandbox.trade/v1/openapi.json
Or skip setup entirely — create a sandbox via REST → and use any AI with the raw API.
Gemini · Gem

Sunflower Gem — launching soon

The Sunflower Gem opens directly inside Gemini with the API pre-configured. We're publishing it to the Gem store now.

Create your own Gem now
1. Open gemini.google.com/gems/create ↗
2. Name: Sunflower Signal Trader
3. Paste the instructions below into the Gem description
4. Set access → "Anyone with the link" → Share
Note: Gemini Gems support natural language instructions. For full API tool use, the Claude MCP or ChatGPT Custom GPT path is more powerful.