The API for Polymarket: Built Different

The problem with Polymarket data

Polymarket moves fast. Billions in volume, markets resolving around the clock, whales moving in and out of positions within seconds of a headline breaking.

If you're building on top of it (a trading bot, an analytics dashboard, an AI agent, a research tool) you've probably hit the same wall we did: the data is there, but getting to it cleanly, instantly, and at scale is genuinely hard.

The official APIs are useful but limited. Cached PnL. Rate-limited endpoints. No webhooks. No backfill. Third-party providers fill some gaps but don't specialise. Everyone's stitching together multiple sources and hoping nothing drifts out of sync.

We didn't want another aggregator with stale caches and 60-minute refresh cycles. We wanted something that felt live.

What we built

Struct is a purpose-built data layer for Polymarket. Every event, market, trade, position, trader, oracle event, series, and tag, accessible through a single consistent interface, indexed from the very first block.

Here's what that looks like in practice:

750M+ trades indexed. We didn't start from last month. Struct has the entire history of Polymarket: every market from genesis, every trade, every resolution, queryable through a clean API.

600K+ markets covered. Active, closed, and archived. With 27 price metric timeframes across each.

Instant latency. Resolution, PnL, and position updates hit Struct the moment they land on-chain. Not after a cache refresh cycle. Not after a polling interval. Instantly.

The full developer stack

We built the infrastructure layer and then kept going:

• REST API: every resource across events, markets, traders, positions, candles, oracle events, series, and tags
• WebSockets: stream trades, oracle events, price updates, and order book changes in real time
• Webhooks: trigger on market creations, resolutions, price thresholds, whale trades, and more
• TypeScript SDK: full type safety and autocompletion out of the box
• Managed backfill: load complete history into your own database, then stream forward in real time
• MCP server: connect AI assistants like Claude, Cursor, and Codex directly to live Polymarket data

Your first API call

curl https://api.struct.to/v1/markets?limit=5&sort=volume \
  -H "Authorization: Bearer YOUR_API_KEY"

{
	"markets": [
		{
			"id": "will-there-be-a-fed-rate-cut-before-july-2026",
			"question": "Will there be a Fed rate cut before July 2026?",
			"probability": 0.62,
			"volume_24h": 4200000,
			"traders": 8341
		}
	]
}

Events, prices, volume, traders, candles. All in one response. No stitching required.

How we compare

The prediction market API space is young and moving fast. Here's an honest breakdown of where Struct sits:

The distinction that matters most: Struct is the only provider that is exclusively focused on Polymarket, ships managed backfill, and delivers instant PnL and resolution latency.

Who it's for

Traders and platform builders

Real-time market intelligence, automated alerts when thresholds are crossed. If you're building a trading platform on top of Polymarket, Struct is your data layer.

Set up a webhook that fires the moment a whale moves, and have your system react before the price updates elsewhere.

AI agent developers

Connect directly to live Polymarket data through our MCP server. Works with Claude, Cursor, and Codex out of the box. Agents can research markets, monitor positions, scan for insider patterns, and act on events autonomously, without writing a single line of infrastructure.

We also ship built-in chat agents you can use right now. More on that below.

Researchers and analysts

The full indexed history of Polymarket: every trade, every position, every price movement, queryable through a clean API. Run backtests. Model resolution accuracy. Detect market microstructure patterns. Quantify how fast information flows into prices after a news event.

The data is all there. We just make it accessible.

Meet StructBot

Not everyone wants to write API calls. StructBot is a conversational interface to the entire Struct data layer. Ask questions in plain English and it queries markets, profiles traders, and surfaces insights without you touching a line of code.

It lives in your dashboard at struct.to/chat and has access to the full Struct API as tools. When you ask a question, it finds the right method, executes it, and presents the results in rich UI components (market cards, trader profiles, data tables) rather than raw JSON.

Two agents, built for different jobs

General is the default. Open-ended exploration across all of Polymarket: trending markets, trader lookups, volume analysis, probability tracking, general Q&A. If you're not sure where to start, this is where you start.

Insider Finder is a specialised agent built around a specific methodology: find price moves first, then identify who traded before the move. It delegates trader profiling to subagents running in parallel, so it can investigate multiple wallets simultaneously and cross-reference behaviour. If you suspect something moved before it should have, this is the agent to reach for.

How it works in practice

Ask StructBot something like:

"Show me the top traders by 30-day PnL" "Which markets saw the biggest probability swings in the last 24 hours?" "Who traded on the Fed rate decision market in the hour before resolution?"

If your question is ambiguous, it'll ask you to clarify with multiple-choice options before proceeding, so you're not left guessing whether it understood you correctly.

You can toggle between two model modes from the chat header: Fast for quick lookups, Capable for deeper analysis that requires more reasoning. Your preference is saved per session.

Built for collaboration

Chats are saved automatically and organised by recency in the sidebar. You can sort them into folders, pin the ones you return to often, and share any conversation via a unique link, either privately (anyone with the link) or publicly (discoverable by anyone). Shared chats are read-only for viewers, and you can revoke access at any time.

File attachments are supported too: drop in a PDF or image alongside your question and StructBot can reference it against live market data in the same response.

AI automations

Beyond the API, we built a workflow layer for people who want to monitor Polymarket without writing code.

Predefined automations (or create your own):

• New Market Analyzer: when a new market goes live, AI summarises it and posts to your Discord or Telegram
• Whale Trade Alert: a large position moves; AI reviews the trader's history and sends context
• Price Spike Detective: sudden probability shift detected; AI explains what changed and why
• Insider Scanner: unusual pre-event positioning flagged with supporting trades

Each automation can go to Discord, Telegram, or any webhook endpoint. No AI layer required if you just want the raw events piped straight through.

The honest caveats

We're in v0.1. That means a few things:

Polymarket only right now. Multi-venue support (Kalshi and beyond) is on the roadmap, but we're not there yet. If you need cross-venue data today, GetDome or Predexon are your options. If you need deep Polymarket data specifically, we think Struct is the right choice.

Early-stage reliability. We've indexed 750M+ trades and the infrastructure is solid, but we're not a five-year-old platform. We'll be transparent about incidents and improvements as we go.

Transparent pricing. The free tier includes 5,000 credits/month to get started. Paid plans range from $49/month (Hobby) to $999/month (Scale), with two months free on annual billing. Enterprise plans are available for custom requirements. Full details at struct.to/pricing.

What's next

We're shipping fast. Here's what's coming:

• Orderbook APIs: full orderbook data including historical snapshots
• Multi-venue support: integrating other prediction markets
• Smarter AI agents: better insider detection, more market categories, richer trader profiling
• More automation templates: volume reporting, arbitrage signals, resolution accuracy tracking

If there's something specific you need from the Polymarket data layer that we don't have yet, tell us. We're building this in public and the roadmap is genuinely user-driven.

Get started

Free tier. No credit card. API key in under two minutes.

→ Get started at struct.to/dashboard → Read the docs at docs.struct.to

Struct is in v0.1. Latency benchmarks are based on internal testing as of February 2026. Multi-venue support is on our public roadmap. Questions or feedback? Reach out at struct.to.