resolvedmarkets.com

To backtest a Polymarket strategy, you need tick-level historical orderbook snapshots — not just price charts — so you can simulate fills against real bid/ask depth at specific timestamps. Resolved Markets provides this: 4.2B+ orderbook snapshots across 184 recurring and event series since March 2026, accessible via REST, WebSocket, MCP, and a built-in backtester, with a free tier and a free API key (no credit card). This guide covers the full workflow: sourcing data, replaying market conditions, defining rules, simulating fills, and evaluating results.

What Historical Polymarket Data You Actually Need

Prediction market backtests fail when they use mid prices alone. A YES contract trading at $0.60 mid might have $50 of depth at $0.59 and $0.61 — your $500 order would move the market. You need:

Resolved Markets captures every snapshot with full bid/ask depth, mid prices, spreads, and crypto spot price. Coverage spans crypto prediction markets, politics and elections, sports and live events, economic indicators, and weather — 100+ markets tracked across 7 categories and 30+ cities.

Step 1: Get Data Access

1. Generate a free API key — Resolved Markets issues one instantly with no account creation and no credit card required.
2. Explore the API — 11 endpoints with live examples you can test directly from the documentation.
3. Pull historical data — Use REST APIs for historical exports and structured schemas, or WebSocket streams for live data. Replay snapshots let you reconstruct specific timestamps.

Example request pattern from the docs:

fetch('/v1/markets/live', {
  headers: { 'X-API-Key': key }
})

For backtesting you'll want the historical export endpoints rather than the live feed. If you sign up on Polymarket through the Resolved Markets referral link, you get 10,000 free API credits added to your account (once per account).

Step 2: Reconstruct Market Conditions at Specific Timestamps

This is where orderbook data separates real backtests from curve-fitting. Time-based queries let you navigate market conditions across specific timestamps and reconstruct event-driven probability movement.

The practical approach:

• Pick your event window. If you're testing a strategy around breaking news or viral moments, pull snapshots minute-by-minute through the reaction period. Resolved Markets explicitly supports replaying market reactions to viral moments, tweets, breaking news, meme cycles, and crowd sentiment shifts.
• Load the full book at each tick. Not just the mid — the entire bid/ask ladder.
• Track liquidity changes. How did depth thin out as the event approached resolution? Did spreads widen?

A concrete example: you want to test whether buying YES on a crypto market 30 minutes before a scheduled announcement is profitable. You need every snapshot in that 30-minute window, plus the resolution outcome, to know whether the position would have settled in your favor.

Step 3: Define Entry/Exit Rules and Simulate Fills Against Depth

Write your rules as explicit conditions on orderbook state, not just price:

• Entry: "Buy YES when mid price crosses $0.55 AND top-of-book ask depth exceeds 200 shares AND spread < $0.02."
• Exit: "Sell when mid reaches $0.70 OR 2 hours before resolution, whichever comes first."
• Position sizing: Cap order size at a fraction of visible depth (e.g., 10% of ask-side liquidity) to avoid unrealistic fills.

Simulating fills correctly: Walk the ask ladder. If you're buying 500 shares and the book shows 200 at $0.56, 200 at $0.57, and 300 at $0.58, your average fill is not $0.56 — it's a weighted average across those levels. Backtests that assume top-of-book fills systematically overstate returns.

Resolved Markets' backtester accepts a strategy described in plain English, then returns the code, equity curve, and trades — useful for quickly testing an idea before building a full simulation.

Step 4: Evaluate Results with Prediction-Market-Specific Metrics

Standard equity curves and trade logs are necessary but not sufficient. Prediction markets have dynamics that equity backtests miss:

• Resolution risk: A position can go to $0 or $1 at settlement. Your equity curve must model binary outcomes, not continuous price paths.
• Time decay near resolution: Prices converge to 0 or 1 as the event resolves. Strategies that hold to resolution face different risk than those that exit early.
• Liquidity evaporation: Depth often thins dramatically in the final hours. A strategy that looks profitable on mid-price signals may be unfillable at scale.
• Spread costs: On a $0.60 contract, a $0.02 spread is 3.3% of notional per round trip. Model this explicitly.

Track: total return, Sharpe ratio (annualized appropriately for event-driven timing), maximum drawdown, win rate, average fill slippage vs. mid, and number of trades where your order size exceeded available depth.

Step 5: Validate and Watch for Common Pitfalls

Out-of-sample testing: Split your data by time period, not randomly. Train on events from one quarter, test on the next. Prediction market regimes shift with news cycles.

Look-ahead bias: The most common failure. If your strategy uses "the resolution outcome" as an input before the market resolved, you've leaked future information. Every signal must use only data available at that timestamp.

Survivorship bias: If you only test markets that resolved (and exclude ones that were cancelled or delisted), your results are skewed. Resolved Markets' coverage of 184 recurring and event series helps here — you can test across the full universe, not just winners.

Overfitting to specific events: A strategy tuned to one viral moment won't generalize. Test across multiple event types (crypto, sports, politics) and time periods.

Validate against live data: Run your strategy in paper-trading mode against the live feed before committing capital. Compare simulated fills to what the live orderbook would have given you.

Quick Reference: The Full Workflow

1. Get a free API key from Resolved Markets (instant, no credit card).
2. Pull tick-level orderbook snapshots for your target markets and time windows via REST historical exports.
3. Reconstruct the full bid/ask ladder at each timestamp.
4. Define entry/exit rules as conditions on orderbook state.
5. Simulate fills by walking the depth ladder, not assuming mid-price fills.
6. Evaluate with equity curves, trade logs, and prediction-market-specific metrics (resolution risk, spread costs, liquidity evaporation).
7. Validate out-of-sample and check for look-ahead and survivorship bias.
8. Paper-trade against live data before going live.

The free tier and 10,000 referral credits make steps 1–3 accessible without upfront cost. The backtester's plain-English strategy input lets you iterate quickly on steps 4–6 before writing production code.

To backtest a Polymarket strategy, you need historical orderbook snapshots — not just final prices — so you can replay the bid/ask depth your strategy would have traded against. Resolved Markets provides tick-level snapshots (full bid/ask depth, mid prices, spreads, and crypto spot price) across prediction, crypto, sports, and weather markets, with REST APIs, historical exports, WebSocket streams, and a backtester that takes a plain-English strategy description and returns code, an equity curve, and trades. A free tier and a free API key (no account creation or credit card required) are available; check the pricing page for current limits.

What you actually need before starting

A backtest is only as good as its inputs. For prediction markets, three data properties matter more than raw price history:

| Requirement | Why it matters | |---|---|---| | Tick-level orderbook snapshots | A strategy that posts or takes liquidity depends on depth and spread, not just the last trade price | | Timestamped snapshots | You must reconstruct the market exactly as it looked when your signal fired | | Category coverage | Crypto, politics, sports, and weather markets behave differently; test on the categories you trade |

Resolved Markets reports 4.2B+ orderbook snapshots across 184 recurring and event series since March 2026, covering 100+ markets and 7 categories. If your strategy depends on a market outside that coverage, the backtest can't validate it.

Step 1: Get data access

1. Generate a free API key — the site states this requires no account creation and no credit card.
2. Browse the API reference (11 endpoints with live examples) and test requests directly from the documentation.
3. Confirm your target markets exist in the historical dataset before writing strategy code.

A minimal live-data call looks like this, which you can adapt to historical endpoints:

fetch('/v1/markets/live', {
  headers: { 'X-API-Key': key }
})

Expected result: you receive structured market data you can query by timestamp. If a market returns no history, stop here — no amount of strategy logic will fix missing data.

Step 2: Reconstruct market conditions at specific timestamps

This is the core of prediction-market backtesting and where most naive backtests fail. Use time-based queries to pull the snapshot state at each moment your strategy would have acted.

For each decision point, extract:

• Best bid and best ask
• Full depth on both sides
• Mid price and spread
• Crypto spot price, if your market is crypto-linked

Then ask: could my order actually have filled at this price, given this depth? A signal that looks profitable on mid prices can vanish once you account for spread and available size.

Step 3: Define strategy logic against real fields

Map your idea to the fields the data actually exposes. For example, a strategy like "buy when the spread narrows and mid price crosses 0.60 with at least X size on the bid" is testable; "buy when sentiment turns bullish" is not, unless you define sentiment as a measurable series.

If you use the built-in backtester, you can describe the strategy in plain English and it returns the code, equity curve, and trades — useful for quickly checking whether an idea is even coherent before building it out.

Step 4: Run the backtest and inspect outputs

Look at three things, in this order:

1. Trades — Did each fill happen at a price and size the orderbook could support? Reject any trade that assumed liquidity that wasn't there.
2. Equity curve — Check drawdown shape, not just final return. A curve that depends on one lucky event is not a strategy.
3. Code — If using the agent-generated backtest, read the code to confirm it implements what you intended, not a plausible-looking approximation.

Step 5: Validate against real market behavior

Prediction markets react to discrete events — viral moments, breaking news, tweets, meme cycles. Resolved Markets explicitly supports replaying these reactions minute by minute. Use this to stress-test:

• Does your strategy survive the volatility spike around a news event?
• Does it degrade when spreads widen during low-liquidity periods?
• Does performance differ across categories (crypto vs. sports vs. politics)?

Common pitfalls

• Backtesting on mid price only. Ignores spread and depth; overstates fills.
• Ignoring the event-driven nature of prediction markets. Probability jumps are often discontinuous, so stop-loss and limit logic behave differently than in continuous markets.
• Testing outside your data coverage. If the market or time period isn't in the dataset, results are fabricated.
• Treating a generated backtest as ground truth. Always read the code and verify the fill assumptions.
• Assuming free means unlimited. A free tier and free API key exist, but credit limits and pricing terms are on the pricing page — verify before scaling.

When this approach fits

Use historical orderbook backtesting when your strategy depends on execution quality — posting liquidity, capturing spread, or sizing into depth. If your strategy only acts on final outcomes and never touches the book, simpler price history may suffice, and the full snapshot pipeline is more than you need.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

Resolved Markets' strategy tester lets you describe a Polymarket strategy in plain English, then returns the generated code, an equity curve, and a trade list built on tick-level historical orderbook snapshots. You can start with a free API key (no account creation or credit card required per the site), and the backtester is listed as free with real historical order book data across prediction, crypto, sports, and weather markets. This walkthrough covers the setup, the backtest loop, and the data-alignment problems that most often break a first run.

What you need before you start

• A Resolved Markets account and API key. The site states you can generate a free API key instantly with no account creation and no credit card.
• A strategy you can state in one or two sentences. The tester works from a plain-English description, so vague inputs produce vague code.
• A target market or series. Coverage includes crypto prediction markets, politics and elections, sports and live events, and economic indicators, with 100+ markets tracked across 7 categories.

Step 1: Get your API key

Generate a free API key from the dashboard. Per the site, there is no account creation and no credit card step — just click and go. Keep the key out of version control; you will pass it as an X-API-Key header on requests.

If you sign up for a new Polymarket account through the referral link, the site says it adds 10,000 free API credits to your Resolved Markets account, once per account.

Step 2: Confirm the data you are backtesting against

Before describing a strategy, check that the market and time window you care about are covered. The dataset is described as 4.2B+ orderbook snapshots across 184 recurring and event series since March 2026, with each snapshot containing full bid/ask depth, mid prices, spreads, and crypto spot price.

Two capabilities matter for strategy design:

If your strategy depends on liquidity or spread behavior, you need the depth fields, not just the mid price. A strategy that looks profitable on mid prices can invert once you fill against the actual book.

Step 3: Describe the strategy in plain English

The tester takes a natural-language description and returns the code, equity curve, and trades. Write the description so it pins down four things:

1. Market and window — which market or series, and the date range.
2. Signal — what triggers an entry. Reference fields the data actually has, such as mid price, spread, or bid/ask depth.
3. Sizing and fills — how much you trade and whether you assume you cross the spread or rest in the book.
4. Exit — time-based, price-based, or event-based.

For example, instead of "buy when it looks cheap," write something like: "On the BTC hourly market, enter when the mid drops more than 3 cents below the 24-hour average mid and the spread is under 2 cents; size at 1% of bankroll; exit at the earlier of a 5-cent gain or 30 minutes." The agent then generates code you can inspect, an equity curve, and the trade list.

Step 4: Run the backtest and read the outputs

The tester returns three artifacts. Check each one:

• Code — read it before trusting the result. Confirm the entry and exit conditions match what you described, and that fills use the orderbook depth rather than an idealized price.
• Equity curve — look for the shape, not just the endpoint. A curve that is flat then jumps once usually means the strategy only traded in one window.
• Trades — check timestamps and fill prices against the snapshots. If a fill price sits outside the bid/ask range recorded at that timestamp, the fill model is wrong.

Step 5: Replay the event window

If your strategy is event-driven, use time-based queries and replay snapshots to isolate the window. The site frames this as replaying real market reactions to viral moments, breaking news, and sentiment shifts, minute by minute. Run the same strategy with and without the event window to see whether the edge comes from the event or from the surrounding baseline.

Common failure points

Time misalignment. Snapshots and your signal timestamps must be on the same clock. If you compute a rolling average from one series and fill from another, you can accidentally use future data. Verify that every input to a decision is timestamped at or before the fill.

Missing data in the window. If a market has gaps, the backtest may silently skip periods or carry forward a stale price. Check snapshot density across your date range before trusting the curve.

Fills that ignore depth. A strategy that assumes it always fills at the mid will overstate returns on thin markets. Use the bid/ask depth fields to cap size at what the book actually held.

Overfitting to one viral moment. A single event window can dominate the equity curve. Test across multiple windows and categories before drawing conclusions.

FAQ

Is the backtester free? The site describes backtesting Polymarket strategies for free with real historical order book data, and lists a free tier. Check the pricing page for current limits.

Do I need a credit card? The site states API key generation requires no account creation and no credit card.

What markets are covered? Crypto prediction markets, politics and elections, sports and live events, and economic indicators, with 100+ markets across 7 categories and 30+ cities tracked.

Can I get the generated code? Yes — the tester shows the code alongside the equity curve and trades.

How far back does data go? The dataset is described as snapshots since March 2026. Confirm coverage for your specific market and window before running.

You can backtest a Polymarket strategy by replaying historical orderbook snapshots — full bid/ask depth, mid prices, and spreads at the tick level — and simulating fills against that depth rather than against a single price. Resolved Markets provides this data through a REST API, WebSocket streams, and a backtester that accepts a strategy described in plain English and returns the code, equity curve, and trades. The approach below works for prediction, crypto, sports, weather, and economic markets, and a free tier is available (the site advertises 10,000 credits on signup, with an additional 10,000 credits for signing up on Polymarket through their referral link, once per account).

Step 1: Get data access

Generate a free API key from the Resolved Markets dashboard — the site states no account creation or credit card is required for the key itself. You then have two access patterns:

The dataset covers 4.2B+ orderbook snapshots across 184 recurring and event series since March 2026, with 100+ markets tracked across 7 categories. Each snapshot includes full bid/ask depth, mid prices, spreads, and crypto spot price — the spot price matters if your strategy trades crypto prediction markets and you want to condition entries on the underlying.

A minimal authenticated request looks like this:

fetch('/v1/markets/live', {
  headers: { 'X-API-Key': key }
})

Step 2: Define the strategy in testable terms

A backtest is only as good as the rules you feed it. Before touching data, write down four things:

1. Market selection — which series or categories, and how you filter (e.g., minimum liquidity, time to resolution, spread ceiling).
2. Entry rule — the exact condition, expressed in fields the data actually has: mid price crossing a threshold, spread narrowing below X, spot price moving Y%, or a time-based query at a specific timestamp.
3. Exit rule — resolution, a target price, a stop, or a time limit.
4. Position sizing — how much you'd commit given the depth available at that moment.

If you use the plain-English backtester, this is where you describe the strategy; the agent converts it to code and runs it. If you're building your own pipeline, the same four items become your function signature.

Step 3: Run the backtest

The core loop is: fetch snapshots in time order → reconstruct the book at each timestamp → check your entry/exit conditions → simulate the fill against available depth → record the trade.

The fill simulation is the part most people get wrong. Don't assume you get filled at the mid price. Walk the book:

• If you're buying, consume asks from the best price upward until your size is filled.
• If you're selling, consume bids from the best price downward.
• Record the volume-weighted average fill price, not the top-of-book price.
• If your size exceeds the depth at your limit, either cap the fill or reject the trade — don't silently fill the whole order.

The expected output is a trade log (timestamp, side, size, fill price, fees if modeled) plus a mark-to-market equity curve built from the mid price between trades.

Step 4: Read the results honestly

Three outputs matter:

• Equity curve — look at drawdown shape, not just the final number. A curve that only works because of one spike is a red flag.
• Trade list — check whether your winners cluster in a few markets or a few time windows. Concentration means the edge may be an artifact.
• Fill realism — compare your assumed fill prices against the spread at entry. If your average fill is at or better than the mid, your simulation is probably too generous.

Common pitfalls

Thin liquidity. Prediction markets can have wide spreads and shallow books, especially far from resolution. A strategy that looks profitable at mid price can lose money once you walk the book. Always simulate against depth.

Short data history. The dataset starts March 2026. Strategies that depend on a full market cycle — election seasonality, a crypto bull/bear swing — may not have enough history to validate. Check how many distinct regimes your sample covers before trusting a result.

Overfitting to viral moments. The platform explicitly supports replaying reactions to viral events, Elon tweets, breaking news, and meme cycles. That's useful for studying behavior, but it's also a trap: if you tune parameters until the strategy nails three specific news spikes, you've fit noise. Test on held-out time periods and markets you didn't tune on.

Ignoring the spot price link. In crypto prediction markets, the outcome probability often tracks the underlying spot price. If your backtest ignores spot, you may attribute to "market sentiment" what is actually a mechanical relationship — and that relationship may not hold in a different regime.

A practical starting sequence

1. Generate an API key.
2. Pull one market series you understand well and export the snapshots.
3. Write a single, simple rule (e.g., buy when mid < 0.30 and spread < 0.02, exit at resolution).
4. Run it with realistic book-walking fills.
5. Compare the equity curve against a buy-and-hold baseline on the same markets.
6. Only then add complexity — and re-test on a different time window each time.

If the simple version doesn't beat the baseline after realistic fills, more parameters won't fix it.