polymarket-sdk

A comprehensive Rust SDK for the Polymarket CLOB API — programmatic trading on prediction markets.

Why This SDK?

Installation

[dependencies]

polymarket-sdk = { path = "." }

tokio = { version = "1", features = ["full"] }

Feature Flags

# Just streaming:

polymarket-sdk = { path = ".", features = ["ws"] }



# Everything:

polymarket-sdk = { path = ".", features = ["full"] }

Quick Start

Public Market Data (no auth)

use polymarket_sdk::PolymarketClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PolymarketClient::new_public(None)?;

    // Fetch markets
    let markets = client.get_sampling_simplified_markets(None).await?;
    println!("Found {} markets", markets.len());

    // Get order book
    let book = client.get_order_book("TOKEN_ID").await?;
    println!("Bids: {}, Asks: {}", book.bids.len(), book.asks.len());

    Ok(())
}

Authenticated Trading

use polymarket_sdk::{ApiCredentials, PolymarketClient, TradeParams, OrderSide};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let creds = ApiCredentials {
        api_key: "your-key".into(),
        secret: "your-secret".into(),
        passphrase: "your-passphrase".into(),
    };

    // Type-level auth: public → authenticated upgrade
    let public = PolymarketClient::new_public(None)?;
    let client = public.authenticate(creds);

    // Now you can call trading endpoints
    let orders = client.get_orders().await?;
    println!("Open orders: {}", orders.len());

    Ok(())
}

Compile-Time Safety

use polymarket_sdk::PolymarketClient;

// This is a public-only client
let public = PolymarketClient::new_public(None).unwrap();

// ✅ Market data works
// let book = public.get_order_book("token").await;

// ❌ This would NOT compile — trading requires authentication!
// let orders = public.get_orders().await;  // compile error!

WebSocket Streaming (requires ws feature)

use polymarket_sdk::stream::PolymarketStream;

async fn stream_example() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = PolymarketStream::connect(None).await?;
    stream.subscribe_market("TOKEN_ID").await?;

    while let Some(event) = stream.next().await {
        match event {
            Ok(msg) => println!("[{}] {:?}", msg.event_type, msg.data),
            Err(e) => {
                if !e.is_retryable() { break; }
            }
        }
    }
    Ok(())
}

API Reference

Public Endpoints (PolymarketClient<Public>)

Authenticated Endpoints (PolymarketClient<Authenticated>)

All public methods, plus:

Architecture

polymarket-sdk/
├── src/
│   ├── lib.rs              # Crate root, feature-gated modules
│   ├── client.rs           # Type-state PolymarketClient<Public|Authenticated>
│   ├── constants.rs        # URLs, chain IDs, contract addresses
│   ├── error.rs            # PolymarketError with is_retryable()
│   ├── http.rs             # reqwest wrapper with retry + rate-limit
│   ├── types.rs            # All data models
│   ├── stream.rs           # WebSocket streaming (ws feature)
│   ├── auth/
│   │   ├── l1.rs           # EIP-712 ClobAuth signing
│   │   └── l2.rs           # HMAC-SHA256 request signing
│   └── signing/
│       ├── eip712.rs       # EIP-712 Order (alloy::sol!)
│       └── order_builder.rs # TradeParams → SignedOrder
├── examples/
│   ├── get_markets.rs      # Public market data
│   ├── place_order.rs      # Full trading flow
│   └── stream_prices.rs    # Live WebSocket streaming
├── Cargo.toml
├── LICENSE
└── README.md

License

MIT