Prediction Market Bots: How They Work, What to Automate, and Where They Fail

A prediction-market bot is software that watches a market, applies a rule and acts on it. That is the whole idea. The hard part is not the code that notices a price difference, because that part is usually the simpler engineering problem. The hard part is everything between noticing and being paid: the executable price rather than the displayed one, the fee, the available depth, the age of the data, whether the order fills at all, and whether both markets settle on the same result. Many bot tutorials focus heavily on that first step.

The short answer
Build the observer before the trader. A first bot that watches, validates and records, without sending a single order, is worth more than a fast one that trades an idea nobody has tested.
Automation does not create an edge. It applies a rule faster and more consistently than a person can, which means a good rule works more often and a bad rule loses more often. This page covers what the different bot types actually do, how a serious one is structured, three Python components you can reuse, where these systems fail, and what HowProsBet’s own measurements do and do not show.

What a prediction-market bot actually does

The word “bot” describes automation, not a strategy. Two systems can share almost all of their code and still be doing completely different things, because the decision they automate is different. Before writing anything, it helps to be clear about which decision you are handing to the machine, and what happens when that decision is wrong.

Polymarket is used as the main concrete example on this page because its documentation and order-book model are public, which makes them easy to reason about. The structure applies to any venue that publishes prices and accepts orders. Where a detail is specific to Polymarket, it is labelled that way.

Bot types
Same code, different decision
Type What it watches What it automates Main failure mode
Monitor or scanner Prices, order books and new markets on one venue Noticing. It surfaces things a human would not sit and wait for Alerting on displayed prices that nobody could actually have traded
Reference or cross-venue scanner A prediction market plus an outside price, usually a bookmaker or exchange Comparing. It converts, devigs and lines two numbers up Comparing two markets that do not settle on the same result, or trusting a stale reference
Event-driven or latency bot An outside signal such as a score feed, a data release or a settlement source Reacting. It trades before the rest of the market has priced the news Being faster than another feed but slower than the market itself
Market-making bot The book it is quoting into, and its own inventory Quoting. It posts, moves and cancels resting orders continuously Getting no fills, or getting filled mainly by traders who know more than it does
Execution or position manager Its own open orders, fills and positions Carrying out a decision already made: sizing, splitting, retrying, hedging, closing Losing track of what it actually holds after a partial fill or a failed leg

The last row is easy to overlook, but it becomes critical as soon as real orders are involved. A position manager makes no money on its own, and it is the component that decides whether the other four can be trusted with real capital. It is also the only one that can tell you, at any moment, what the system believes it owns and whether that belief is correct.

The architecture of a real bot

Whatever the strategy, a serious system has the same seven stages. They are worth separating in code as well as in your head, because each stage fails in its own way and a failure in an early stage is usually invisible in a later one. A bad price that passes normalisation does not announce itself at the execution stage. It just loses money quietly.

Architecture
Seven stages, seven ways to be wrong
Data, normalize, signal, risk gates, execution, reconciliation, logging. Each stage answers one question. Each stage has its own failure.
1
Data
Did the input arrive, and is it current? Every observation gets a timestamp from your own clock as well as the venue’s.
Fails as: a dropped WebSocket that reconnects silently, a cached response, a feed that is still sending but no longer updating.
2
Normalize
Are two markets really describing the same outcome, in the same direction, under the same rules? This includes turning decimal odds into probabilities and mapping teams, lines and periods.
Fails as: a draw that one side treats as a loss and the other refunds, a market that settles on regular time while the other includes overtime, an inverted YES and NO.
3
Signal
Is the difference economically meaningful, or is it inside the noise of your own reference? A signal is a claim that your estimate is better than the market’s, and that claim needs a reason.
Fails as: a midpoint used as if it were a tradable price, a bookmaker margin left in the reference, a threshold tuned until the backtest looked good.
4
Risk gates
Does it survive fees, depth at the size you want, a maximum data age and a settlement check? This is where most candidates should die, and where the interesting engineering is.
Fails as: gates that exist but are applied after the decision, or thresholds that were loosened once because a run produced nothing.
5
Execution
Can the position actually be taken, at that price, in that size, right now? Order type matters here more than speed does.
Fails as: a partial fill, a rejection, a resting order that never trades, or a second leg that has moved by the time the first one is done.
6
Reconciliation
Did the bot get what it thought it asked for? Compare intended position against confirmed fills and settled outcomes, from the venue’s own records rather than from your own optimism.
Fails as: a system that believes it is hedged while holding one open leg.
7
Logging
Can the result be audited honestly, weeks later, by someone who wants to prove you wrong? That includes every candidate you rejected and why.
Fails as: a log that records only the trades that happened, which makes every strategy look selective and none of them testable.

Notice how little of that is about speed. Stages two, four, six and seven contain most of the work and none of the glamour. They are also the stages that survive a change of venue, a change of SDK and a change of strategy.

Build the observer before the trader

The most useful first version of a prediction-market bot places no orders at all. It connects to the data, writes down what it sees, applies the rules you would have traded on and records what happened next. Then it does that for long enough to produce a dataset you did not have before.

This is not caution for its own sake. An observer answers a question a live bot cannot: would this rule have produced anything worth trading, under conditions fixed in advance? A live bot conflates two things that need separating, because when it loses money you cannot tell whether the signal was wrong or the execution was. The observer isolates the first question and costs nothing but time.

Scope
What the observer does, and what it never does
It does
Ingest the data feed continuously
Timestamp every observation on arrival
Normalize comparable markets and outcomes
Read order-book depth, not just the top level
Calculate the executable price for the size it wants
Apply the venue’s fee formula
Reject anything older than a fixed age limit
Require a minimum net edge after costs
Log accepted candidates
Log rejected candidates and the reason
Record the market state some seconds and minutes later
It does not
Send an order of any kind
Hold authenticated trading credentials
Change its thresholds mid-run
Discard observations that look uninteresting
Round, smooth or fill gaps in the raw record
Assume the top of the book is available at size
The rejected candidates are the part people leave out, and they are the part that makes the dataset worth having. A log containing only interesting signals cannot tell you how often your rule fires, how often it was nearly right, or which gate is actually doing the work. It produces a record that agrees with you by construction.

There is a second reason to log rejections. Over a few weeks, the distribution of rejection reasons tells you where your idea really stands. If almost everything is rejected for insufficient depth, the problem is size, not signal. If almost everything is rejected because the data was too old, the problem is infrastructure. If nothing is ever rejected, your gates are not doing anything and you should check them before you trust them.

Three components worth writing yourself

The examples below are illustrative and self-contained. They are not copied from live platform code, and the numbers in them are invented to make the arithmetic visible. They are the three pieces that tend to be missing from published bot examples, and they are the pieces that keep working when an SDK changes.

1. The executable price, not the displayed one

An order book shows a best ask and the size available at that price. Buying more than that size means buying the next level too, and the next, at worse prices. The price you will actually pay is the weighted average across the levels you consume. On Polymarket, the public market WebSocket channel sends an aggregated book snapshot with a price and a total size for each level, which is exactly the shape this function expects.

Python
# Illustrative ask levels. These numbers are invented for the example.
# Each level is (price_per_share, shares_offered_at_that_price).
ASKS = [
    (0.50, 40),
    (0.51, 120),
    (0.53, 300),
]


def executable_buy(asks, shares_wanted):
    """Price a buy by walking the ask side from the best level up.

    Returns how much could be filled, the total cost, the weighted
    average price and the worst level touched. `asks` must be sorted
    from lowest price upwards.
    """
    filled = 0.0
    cost = 0.0
    worst_price = None

    for price, available in asks:
        if filled >= shares_wanted:
            break
        take = min(available, shares_wanted - filled)
        filled += take
        cost += take * price
        worst_price = price

    if filled == 0:
        return None

    return {
        "requested": shares_wanted,
        "filled": filled,
        "complete": filled >= shares_wanted,
        "cost": round(cost, 6),
        "avg_price": round(cost / filled, 6),
        "worst_price": worst_price,
    }


print(executable_buy(ASKS, 40))
# {'requested': 40, 'filled': 40.0, 'complete': True, 'cost': 20.0,
#  'avg_price': 0.5, 'worst_price': 0.5}

print(executable_buy(ASKS, 300))
# {'requested': 300, 'filled': 300.0, 'complete': True, 'cost': 155.4,
#  'avg_price': 0.518, 'worst_price': 0.53}
The displayed price was 0.50. At 300 shares the real price is 0.518, and the worst level touched is 0.53. Any calculation that used 0.50 for the whole position was wrong by nearly two cents per share before a single fee was applied. The general version of this problem is covered in sports betting liquidity, explained.

2. A candidate that has to survive its own gates

The second component turns an apparent edge into a decision. It takes your reference probability, the executable price from the first function, a fee, an explicitly supplied slippage allowance and the age of the data, and it returns either an acceptance or a named rejection reason. The rejection reason is as important as the acceptance.

The fee here uses Polymarket’s published taker formula, which its documentation states as shares multiplied by the fee rate, the price, and one minus the price. The published rate for sports markets is 0.05, and the documentation notes that makers are not charged fees and that some categories are fee-free. Rates and categories change, so read them from the venue rather than hard-coding them permanently.

Python
from dataclasses import dataclass
from typing import Optional

# Polymarket's published sports taker rate, read on 29 September 2026.
# Read it from the venue at runtime rather than trusting this constant.
SPORTS_TAKER_RATE = 0.05


def taker_fee(shares, price, fee_rate):
    """Published formula: shares * feeRate * p * (1 - p)."""
    return shares * fee_rate * price * (1 - price)


@dataclass(frozen=True)
class Gates:
    # Illustrative thresholds. They are choices, not researched optima.
    max_data_age_s: float
    min_net_edge: float
    min_shares: float


@dataclass
class Candidate:
    market_id: str
    reference_prob: float   # your own fair estimate, devigged if it came from a bookmaker
    exec_price: float       # weighted executable price from example 1
    shares_available: float
    data_age_s: float
    slippage: float         # supplied explicitly; zero must also be an explicit assumption


def evaluate(c: Candidate, g: Gates, fee_rate=SPORTS_TAKER_RATE):
    gross_edge = c.reference_prob - c.exec_price
    fee_per_share = taker_fee(1.0, c.exec_price, fee_rate)
    net_edge = gross_edge - fee_per_share - c.slippage

    if c.data_age_s > g.max_data_age_s:
        return "reject", "stale_data", net_edge
    if c.shares_available < g.min_shares:
        return "reject", "insufficient_depth", net_edge
    if net_edge < g.min_net_edge:
        return "reject", "edge_below_threshold", net_edge
    return "accept", None, net_edge


gates = Gates(max_data_age_s=2.0, min_net_edge=0.01, min_shares=50)

candidate = Candidate(
    market_id="illustrative-market",
    reference_prob=0.55,
    exec_price=0.54,
    shares_available=120,
    data_age_s=1.2,
    slippage=0.0,  # illustrative explicit assumption
)

state, reason, net_edge = evaluate(candidate, gates)
print(state, reason, round(net_edge, 5))
# reject edge_below_threshold -0.00242
The gross edge looked like a full cent per share. The taker fee at that price is about 0.0124 per share, so the net figure is negative before slippage is even considered. This is the arithmetic that decides most candidates, and it is why the fee has to sit inside the decision rather than in a note at the end. Turning a bookmaker price into a usable reference is covered in how to devig betting odds, and the two cost models are compared in prediction market fees vs. bookmaker vig.

3. Shadow-mode logging that can be audited later

The third component is the one that turns an observer into evidence. It is an append-only event log: each observation is one line, and each line carries an event_type. The first observation of a candidate is a candidate event, and a later look at the same market is a separate followup event sharing the same record_id. Nothing is ever rewritten, so counting candidate events counts candidates exactly once. No order is sent anywhere in this code.

Python
import json
import time
import uuid

LOG_PATH = "shadow_events.jsonl"


def append_event(event, path=LOG_PATH):
    """Append one JSON line. Nothing already written is ever rewritten."""
    with open(path, "a", encoding="utf-8") as f:
        f.write(json.dumps(event) + "\n")


def observe(candidate, gates, venue_ts_ms=None, rules_version="v1"):
    # One "candidate" event per observation, accepted or rejected.
    state, reason, net = evaluate(candidate, gates)
    record_id = str(uuid.uuid4())
    append_event({
        "event_type": "candidate",
        "record_id": record_id,
        "observed_at": time.time(),        # local clock, seconds since epoch
        "venue_timestamp_ms": venue_ts_ms,  # the venue's own timestamp, if it sends one
        "market_id": candidate.market_id,
        "reference_value": candidate.reference_prob,
        "exec_price": candidate.exec_price,
        "depth_shares": candidate.shares_available,
        "fee_assumption": taker_fee(1.0, candidate.exec_price, SPORTS_TAKER_RATE),
        "expected_net_edge": net,
        "state": state,                    # "accept" or "reject"
        "reason": reason,                  # rejection reason, None when accepted
        "rules_version": rules_version,    # which fixed rule set produced this decision
    })
    return record_id


def add_followup(record_id, seconds_later, best_bid, best_ask):
    # A separate event, later, sharing the candidate's record_id.
    # What did the market do after the signal? The candidate line is never touched.
    append_event({
        "event_type": "followup",
        "record_id": record_id,
        "observed_at": time.time(),
        "after_s": seconds_later,
        "best_bid": best_bid,
        "best_ask": best_ask,
    })


# Later, analysis joins the two event types on record_id:
# candidates = [e for e in events if e["event_type"] == "candidate"]
# followups  = [e for e in events if e["event_type"] == "followup"]
Three details carry most of the value. The append-only shape means a candidate is written once and never edited, so a later count of candidate events is a true denominator rather than one inflated by follow-ups. The rules_version field lets you prove which rule set produced a decision, which matters when you change a threshold. And the separate followup events let you ask afterwards whether the price moved the way the signal predicted, separately from whether you could have traded it.

Why this page does not publish a complete live-trading bot

A full authenticated trading implementation would be the least durable part of this article. Authentication schemes, SDK signatures, endpoints, order semantics and platform rules all change, and a copied implementation that is six months stale is worse than none, because it fails in ways the person running it does not expect.

More importantly, order submission is not the hard part. Once a candidate has survived executable pricing, fees, depth, age and a settlement check, sending it is a few lines against whichever client library the venue currently publishes. The intellectual work sits before that call. That is the part worth teaching, and the part that transfers between venues.

Where prediction-market bots actually fail

These are different classes of failure, and they need different fixes. A correct signal can be untradeable. A tradeable signal can be unprofitable. A profitable trade can be undone at settlement. Grouping them makes it easier to see which one you are looking at.

Failure classes
Five ways a working bot still loses
Data and semantics
Stale data that still looks live
A reference feed slower than you assumed
A WebSocket that drops and silently reconnects
Malformed or missing messages
Two markets that describe different outcomes
An inverted side or a mismapped line
Pricing
Top of book unavailable at the size you need
A spread wide enough to swallow the edge
Fees applied after the decision instead of inside it
Slippage treated as zero
A midpoint used as a tradable price
Execution
Partial fill on one leg
Zero fill on a resting order
The second leg moves before it is placed
Rejection or cancellation
An order held in a delay window and then refused
Fills that arrive only when the market is about to move against you
Settlement
Two venues resolving the same event differently
A draw, void or push that only one side refunds
A disputed resolution that delays the money
A market whose written rules differ from its title
Method
A backtest tuned until it looked profitable
A pattern that only exists in the data it was found in
Incomplete logging that hides the failures
Rejected candidates never recorded
Thresholds changed after seeing the result
The last group is the most expensive, because the others announce themselves. A method failure produces a system that looks like it works right up until real money is involved.

Two failures deserve a sentence of their own. The first is adverse selection: a resting order earns nothing while it waits, and the orders that do fill are often the ones where somebody better informed was happy to take the other side. The second is second-leg risk, which applies to any strategy defined as a pair. Until both legs exist, you hold a one-sided position, and the arithmetic you planned around is no longer the arithmetic you have. The cross-venue version of that problem is covered in prediction market vs sportsbook arbitrage.

What HowProsBet measured

These are bounded tests with fixed rules, published in full with their samples and limitations on the prediction market execution tests page. They are useful here for one reason: they show that different apparent edges fail at different points in the chain above. None of them shows that bots do not work, and none of them involved live order placement.

HowProsBet measurements · bounded tests, fixed rules
A quote is not a fill
HPB-O-002 · 21 Aug 2026
26 maker candidates were frozen and the live market was watched for 600 seconds without placing any orders. 22 were valid at the start of the window. None of the 22 reached a full strict price-priority shadow fill. This does not show a long-run fill rate: the window was short and the fill rule deliberately strict.
A price move is not a profitable round trip
HPB-O-003 · 22 to 23 Aug 2026
A replay around repricing events produced 11 raw strict contacts and 5 fully evaluated episodes, all five with enough recorded depth for a probe-sized exit. None remained net-positive after round-trip economics that were fixed before the replay. Five episodes is a small sample and the result depends on those cost assumptions.
Discovery data flatters a pattern
HPB-O-004 · historical data
Weighted maker markout was +0.002850293 per share in January and February 2026 discovery data, and -0.000059664 per share, roughly zero, in untouched March 2026 data. 30 of the 91 evaluable segments were positive in both periods. These are historical discovery and holdout figures, not a replication on current markets.
Faster than another feed is not faster than the market
HPB-O-005 and HPB-O-006 · 24 Aug 2026
On the Madrid-Barajas weather report, METAR.ws delivered the same report 123.611295 seconds before AviationWeather. The relevant market was already effectively terminal before the faster report arrived, and no stale executable price was observed in the immediate follow-up window. In the BTC boundary run the pattern repeated at a much shorter scale: the exchange recorded the market as terminal at 13:05:02.200 and the public real-time signal reached the receiver at 13:05:02.960093, about 0.76 seconds later. Both runs used public sources only, and each conclusion rests on a single decisive case.
A sportsbook moving first was not, by itself, a tradable signal
HPB-O-007 · 25 Aug 2026
Two replications using accessible sportsbook reference feeds, BWin and SBOBET, polled 273 times each and produced no qualifying executable prediction-market candidate under fee and depth gates fixed before the runs. This was a single-leg test of the prediction-market side against a reference feed. It was not a test of a locked two-leg position, and no sportsbook leg was placed.
Sometimes the data stops the test
HPB-O-009 and HPB-O-010 · 28 Aug to 1 Sep 2026
In one persistent run, exactly 1 of 45 observed clears could be valued against a strict independent price, and in the next controlled run none of 25 passed at 300, 450 or 600 seconds of allowed price age. The bottleneck was independent prices for the exact pair of outcomes, not an overly strict freshness rule, and that single clear was a trade between other participants rather than a HowProsBet fill. Separately, a run with 96 eligible and 96 clean markets was declared formally invalid because five external WebSocket JSON errors breached a quality gate set before the run.
What this set does not show: long-run fill rates, expected value, or anything about faster private routes, co-located infrastructure or sharper reference prices. None of the published measurements established positive realised economics, and none of them transfers automatically to sportsbooks or betting exchanges.

The last record is worth sitting with if you are building a pipeline. A run can look clean and still be discarded, because the rule for what counted as valid data was fixed before the results were visible. Five malformed messages would not invalidate every pipeline. In this run, five were enough to breach the quality gate set in advance, so the run was discarded rather than quietly judged by a different standard afterwards.

A sensible development ladder

Each stage is allowed to do one more thing than the one before it, and each has to demonstrate something before the next one starts. The point of the ladder is that a failure at any stage tells you something specific, instead of leaving you with a losing balance and no explanation.

Development ladder
Earn the right to send the next kind of order
1
Observer
May: read public data and write it down. Must show: clean, continuous, correctly timestamped data, with gaps and reconnections visible in the record rather than hidden.
2
Candidate logger
May: apply the rules and classify what it sees. Must show: that it can explain every rejection by name, and that the distribution of reasons makes sense.
3
Shadow execution
May: simulate fills against recorded market activity. Must show: that candidates would have filled under a rule written down before the outcome was observed, and that the simulated economics include every cost.
4
Micro-live execution
May: send small real orders under a hard exposure cap and an automatic stop. Must show: that real orders behave like the shadow assumed, and that every fill, rejection and settlement reconciles against the venue’s own records.
5
Scale
May: increase size and frequency. Must show: realised economics across enough live executions to distinguish a process from noise, at the size you intend to trade. How many that is depends on your edge and variance, which is the subject of how to verify your betting edge.
Moving up a stage is a decision, not a default. Each one should be taken deliberately, with the evidence from the stage below written down somewhere you cannot quietly edit.

Stage four is where most of the surprises live. Shadow fills are simulated against activity that happened without your order in the book, so a real order changes the thing it is measuring. That gap is exactly why micro-live exists as a separate stage rather than as the first one.

APIs and data

What follows is read from Polymarket’s official documentation on 29 September 2026, including its order-lifecycle documentation, fee schedule, real-time data documentation and resolution rules. Platform behaviour changes, sometimes without notice, so treat this as a map of what to check rather than as permanent fact. Anything the documentation does not establish is marked as unestablished rather than filled in with a plausible guess. Data feeds and access routes for sports data in general are covered in sports betting APIs explained.

Polymarket specific
What the official documentation establishes
Subject Documented position
Surfaces Separate REST services for market discovery, the order book, and position and activity data, plus WebSocket channels for the public book, for authenticated account updates, for public real-time data and for live game status. Public market data needs no credentials.
Authentication Two layers. The wallet signs a typed message to establish control and create or derive credentials, then private requests are signed with those credentials using HMAC-SHA256. Order placement uses both: the credentials authenticate the request and a wallet signature authorises the order itself.
Order types All orders are limit orders. Good till cancelled, good till date, fill or kill, and fill and kill are documented, along with post-only orders, which are rejected rather than executed if they would cross the spread. A market order is described as a limit order priced to execute immediately.
Delays before matching Some markets hold a marketable order before matching. The documentation describes a 250 millisecond hold on selected crypto and finance up or down markets, and a configured delay window on configured sports markets. During either delay the order is pending and cannot be cancelled, and it is rejected rather than matched if a check fails when the delay expires.
Partial fills Partial fills cannot be cancelled. Only the unfilled portion of an order can be. Price improvement goes to the taker.
Book feed The public market channel sends a full aggregated book snapshot with a timestamp and a content hash, then price-level deltas in which a size of zero means the level was removed, plus trade and tick-size events. A client heartbeat is expected every 10 seconds.
Fees A taker fee applied at match time on some categories, calculated as shares multiplied by the fee rate, the price and one minus the price. Makers are not charged. The published sports taker rate is 0.05, rates differ by category and some categories are fee-free. The dollar fee peaks near a price of 0.50.
Rate limits Published per endpoint and enforced on sliding windows. Exceeding a limit throttles requests rather than rejecting them outright, and order and cancellation requests also carry separate per-signer limits. Read the current table before designing a polling loop.
Resolution Each market’s written rules, not its title, define how it resolves, including the source and the edge cases. An outcome is proposed to an optimistic oracle and there is a 2 hour challenge period, so an undisputed resolution is described as final about 2 hours after proposal, while a disputed one is described as taking 4 to 6 days.

Three of those rows have direct consequences for a bot. Post-only orders guarantee the maker side, which matters when the fee structure charges only takers, but a maker order is worth nothing until it fills. The delay window means an order can be accepted, held, and then refused, so the code has to treat a submitted order as pending rather than done. And partial fills cannot be undone, which is the whole argument for choosing the order type deliberately instead of defaulting to whatever an example used.

Broker access and automation without code

Some betting brokers offer prediction-market prices inside an ordinary betting account, which changes the access question but not the execution question. How that works on one broker is covered in Polymarket through Sportmarket. Two points matter for anyone automating. On Sportmarket, prediction-market fees are built into the displayed odds, so the price available through the broker is the price that matters rather than a raw direct-venue ask. Direct Polymarket availability and Sportmarket availability are separate questions: Sportmarket does not publish a Polymarket-specific country matrix, so this page does not assume that Polymarket.com’s direct restrictions either apply unchanged to the broker feed or are bypassed by it.

On the programmatic side, Sportmarket does publish API documentation covering session login, an asynchronous data stream, the betslip and order placement, with access granted on request rather than open to everyone. That documentation does not establish prediction-market execution as an available API route, so this page does not treat it as one. Sportmarket also offers Tradeball, a rule-based bot tool that its help centre describes as letting a customer set conditions under which bets are placed automatically, currently for football. It is worth knowing that the no-code route exists, and worth noting that it automates the decision without solving any of the validation problems described above.

Testing methodology

A backtest answers a question that is easier than the one you need answered. It asks whether a rule, applied to data you already have, produces a positive number. It cannot tell you whether the prices in that data were available to you, in your size, at the moment your rule fired.

The practical fixes are unglamorous. Split your data into a discovery period, where you are allowed to search and tune, and a holdout period that you do not look at until the rules are frozen. Record both your own arrival timestamp and the venue’s timestamp for every observation, because the difference between them is the only way to detect a feed that has fallen behind. Do not compare a value measured on your clock with one measured on a server’s clock as though they were the same thing.

Fix the rules before the run, in writing, including the fee assumption, the depth requirement, the maximum data age, the minimum edge and what counts as valid data. A run that is judged against rules written afterwards is a description of the data, not a test of an idea. And separate signal quality from execution quality, because they need different remedies: a signal that predicts direction but never fills is an execution problem, while a signal that fills easily and then loses is a modelling problem.

A good test record should let somebody else answer these questions afterwards without asking you: what exactly was being tested, over what window, with what denominator, under what execution and cost assumptions, with what result, and what the result does not establish. If any of those is missing, the record is an anecdote.

Before you move from a script to live execution

Checklist
Eleven questions with answers you can point to
Market definition
Are both markets describing exactly the same outcome, including draws, extra time and abandonment?
Can either venue void or settle differently from the other?
Is the reference price devigged where it needs to be?
Pricing
How old is each data point at the moment of the decision?
Is the size you want actually available?
What is the weighted executable price at that size, not the top of book?
Which fees apply, at the price you would pay?
Execution
What happens if only one leg fills, or one leg fills partially?
Can every live order be reconciled afterwards against the venue’s own record?
Evidence
Are rejected candidates logged with their reasons?
Is there an untouched evaluation period that the rules were never tuned against?

Prediction market bots: common questions

FAQ
The questions that come up most
Are prediction-market bots profitable?
Some participants clearly do make money in these markets, and published academic work has documented realised arbitrage on Polymarket at scale. That says nothing about whether a particular bot, at a particular speed, with a particular cost structure, is profitable. HowProsBet has not published a measurement establishing positive realised economics for any of the strategies it tested, and none of those tests involved live order placement. A return figure for a commercial bot should be treated as an unverified claim unless its methodology, execution assumptions and realised trading record are disclosed.
Do you need to be a programmer?
To build the system described here, yes, at roughly the level of comfortable intermediate Python. Rule-based tools exist that automate bet placement without code, such as the Tradeball tool Sportmarket describes in its help centre, and they remove the coding work rather than the thinking work. The validation questions in the checklist above still have to be answered by somebody.
Is a Polymarket bot just an arbitrage bot?
No. Arbitrage is one of at least five things a bot can automate, and it is the one with the strictest requirements, because a locked position needs both sides bought at known prices on markets that settle identically. Monitoring, reference pricing, event reaction, quoting and position management are separate jobs with separate failure modes. The cross-venue lock is covered separately in prediction market vs sportsbook arbitrage.
How fast does a bot need to be?
It depends entirely on the strategy, and speed is only useful relative to the market rather than to another data source. In HowProsBet’s weather run, one public source delivered the same report 123.611295 seconds before another and the market was already effectively terminal before the faster report arrived. Speed is the right investment when your strategy competes on reaction time and you have established that the market has not already moved. It is the wrong first investment for almost everything else.
Should you start with live trading?
Starting live means paying real money for information you could have collected for free, and receiving it in a form that cannot distinguish a bad signal from bad execution. Start read-only, add candidate classification, then shadow fills, then small real orders under a hard cap. Each step answers a question the previous one could not.
What is the hardest part to automate?
Normalisation and reconciliation are among the hardest parts. Deciding that two markets genuinely describe the same outcome under the same rules is judgement work that resists clean code, and it has to be right before anything downstream means anything. Reconciliation is the mirror image: knowing exactly what you hold after a partial fill, a rejection or an unusual settlement.
Can a bot remove execution risk?
It can reduce the delay between two actions, which shrinks the window in which a price can move against you. It cannot remove fees, depth limits, partial fills, rejections, settlement mismatches or account restrictions. A fast system running a flawed check reaches the wrong answer more often, not less.
Is a backtest enough?
No, for two reasons. A backtest usually prices trades at displayed rather than executable prices, and it is run on the data the rule was found in. HowProsBet’s own historical map is a first-party example of the second problem: weighted maker markout was positive in the discovery months and roughly zero in the untouched month that followed. A holdout period the rules were never tuned against is the minimum honest check.

Where to go from here

Last reviewed: 29 September 2026. Platform behaviour in the APIs and data section was read from Polymarket’s official documentation on that date, and the Sportmarket points from its public help centre and API documentation. Fee rates, order semantics, rate limits, delay rules and resolution timings change, so check the primary sources before relying on any of them in code. The Python examples are illustrative: their numbers and thresholds are invented for teaching and are not measured values or recommended settings.

Scroll to Top