PolyEdge Rust SDK

Official Rust SDK for PolyEdge — Ultra-Low-Latency Polymarket Mempool Trade Streaming & Real-Time On-Chain Analytics API.

Engineered for Polymarket copy-trading bots, professional traders, and prediction market builders. Capture pending trades pre-block and track smart money with institutional-grade on-chain analytics.

Key Features

• 4 First-Class Namespaces: Aligned with OpenAPI 3.1:
  • client.streams(): Real-time SSE trade streaming, sessions & filter management.
  • client.analytics(): Polymarket trade attribution, trader leaderboards, market settlement audit.
  • client.account(): User profile, API keys, request telemetry, and ledger.
  • client.subscription(): Pricing tier catalog, upgrade quotes, and promo codes.
• Async Streaming with Tokio & Reqwest:
  • 45s Keep-Alive Watchdog: Native read-timeout detection automatically cleans up dead socket half-open connections.
  • Atomic Last-Event-ID Resumption: Seamlessly captures buffered trades on reconnection.
  • Fail-Fast for Fatal Errors: Immediate non-retry bailout on HTTP 401/403/404.
  • Standard Futures Stream: Implements futures_util::Stream<Item = Result<LiveTransaction, StreamError>>.
• Pre-Block Polymarket Trade Streaming: Peered with 100+ Polygon nodes to capture pending Polymarket trades pre-block. The World's Fastest — verify yourself.

Installation

Add to Cargo.toml:

[dependencies]
polyedge = "1.2.0"
tokio = { version = "1", features = ["full"] }
futures-util = "0.3"

Or via cargo add:

cargo add polyedge tokio --features full futures-util

Quick Start

1. Initialize Client & Query Analytics

use polyedge::PolyEdgeClient;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("POLYEDGE_API_KEY").expect("POLYEDGE_API_KEY is required");
    let client = PolyEdgeClient::new(&api_key);

    // 1. Query Top Traders Leaderboard
    let leaderboard = client.analytics().get_leaderboard(Some(5), None).await?;
    println!("Total active traders: {:?}", leaderboard.total_count);

    if let Some(traders) = leaderboard.traders {
        for (i, t) in traders.iter().enumerate() {
            let addr = t.profile.as_ref().and_then(|p| p.address.as_deref()).unwrap_or("0x...");
            let name = t.profile.as_ref().and_then(|p| p.name.as_deref()).unwrap_or("Anon");
            let pnl_usd = (t.total_pnl.unwrap_or(0) as f64) / 1e6;
            println!("#{i} {addr} ({name}) - PnL: ${pnl_usd:.2}");
        }
    }

    Ok(())
}

2. Real-Time Mempool SSE Trade Stream

use futures_util::StreamExt;
use polyedge::PolyEdgeClient;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("POLYEDGE_API_KEY").expect("POLYEDGE_API_KEY is required");
    let client = PolyEdgeClient::new(&api_key);

    // Connect to active stream
    let stream = client.streams().connect("your_stream_id");
    let mut stream_iter = Box::pin(stream.subscribe());

    println!("Listening for real-time Polymarket mempool trades...");

    while let Some(item) = stream_iter.next().await {
        match item {
            Ok(tx) => {
                let tx_hash = tx.tx_hash.as_deref().unwrap_or("");
                let short_hash = if tx_hash.len() > 18 { &tx_hash[..18] } else { tx_hash };
                let question = tx.market.as_ref().and_then(|m| m.question.as_deref()).unwrap_or("");
                let taker = tx.taker.as_ref();
                let outcome = taker.and_then(|t| t.outcome.as_deref()).unwrap_or("");
                let side = taker.and_then(|t| t.side.as_ref());
                let shares = taker.and_then(|t| t.shares.as_deref()).unwrap_or("0");
                let makers_count = tx.makers.as_ref().map(|m| m.len()).unwrap_or(0);

                println!("⚡ [Live Trade] Tx: {short_hash}...");
                println!("   Market: \"{question}\"");
                println!("   Taker: {outcome} ({side:?}) | Shares: {shares}");
                println!("   Matched Makers: {makers_count} orders");
            }
            Err(e) => {
                eprintln!("Stream notice/reconnect: {e:?}");
            }
        }
    }

    Ok(())
}

Complete API Service Reference (28 Methods)

1. Streams Service (client.streams())

2. Analytics Service (client.analytics())

3. Account Service (client.account())

4. Subscription Service (client.subscription())

License

MIT © 2026 PolyEdge Labs