Betfair Exchange API Bot Coding: Execution Under Minimum Liquidity
Thin markets will gut your bot faster than any logic bug you can write. When you code against the Betfair Exchange API and the available back or lay size collapses to a few pounds, every assumption baked into your execution layer gets stress-tested in the worst possible way. This is where most traders discover their bot was never actually built for reality β it was built for a fantasy of deep, forgiving books.
The Liquidity Trap Nobody Warns You About
Minimum liquidity is not an edge case. It is Tuesday afternoon on a minor handicap, it is the fifth tier of a South American league, it is the final furlong of a race nobody is watching. Your bot fires a Betfair Exchange API bot request expecting a clean fill, and instead it walks the ladder three ticks deep, eating into the spread and leaving you with a position you never wanted at a price you never modeled. π The execution under minimum liquidity problem is fundamentally a matching-engine problem disguised as a trading problem.
Here is the brutal truth: the API does not care about your intent. It matches against what is there. If the top of book holds four pounds and you send ten, you get four at the best price and the remainder chases whatever is next. Your average fill price degrades geometrically as liquidity thins. A bot that ignores available size at the touch is not a trading bot β it is a donation mechanism.
Pre-Trade Size Validation Is Non-Negotiable
Before your order construction routine ever serializes a bet, it must query the current market book and compute the executable size at your acceptable price. Pull the available to back and available to lay figures for every relevant price level. If the sum across your tolerated price range is below your stake, do not send. Log the shortfall, flag the market as illiquid, and move on. This single gate eliminates the majority of accidental market impact in thin books.
But validation alone is not enough. The book moves between your read and your write. You need a stale-data threshold β anything older than roughly 250 milliseconds in a thin market is archaeological. Re-read, revalidate, then transmit. The round-trip latency budget on a minimum-liquidity market should be tighter than your standard execution path, not looser. Sloppy engineers reverse that and pay for it.
Order Types and the Fill Reality Check
Limit orders with a hard price ceiling are your only sane default in low-liquidity conditions. Market orders, where supported through the exchange's order types, are a controlled demolition in a thin book β you surrender price discovery entirely. Even persistent limit orders need a time-to-live guard. An unfilled order sitting in a market that has since dried up is a liability, not an opportunity.
Track the partial fill behavior of your orders at the API level. When the fill ratio consistently underperforms the requested stake, your sizing logic is misaligned with market depth. Implement a dynamic stake scaler that reduces order size proportionally to available liquidity at the touch. If the top level holds six pounds, your stake should not be thirty. A scaler that caps at a fraction of visible depth keeps you honest and keeps slippage bounded.
Cancel and Replace Discipline
Thin markets punish stale resting orders with adverse selection. Your cancel-and-replace loop must run on a defined cadence, not on a whim. Set a maximum age per order β say three seconds in volatile low-liquidity conditions β and force a reprice cycle. But respect rate limits on the exchange's order endpoint. Hammering the API with cancels and replaces will get your key throttled, and a throttled bot in a moving market is a dead bot.
Batch your cancel operations where the API permits. Sequence your writes so a cancel always precedes a replace for the same selection. Never let two live orders for the same bet coexist, even momentarily β in a thin book that is a guaranteed double exposure. Your state machine must treat cancel and replace as a single atomic transaction from the perspective of your position accounting. π―
Logging, Replay, and the Liquidity Signature
Capture the full market book snapshot alongside every order you send. Timestamp, price ladder, available sizes, fill outcomes. Build a liquidity signature for each market you trade β the typical depth at each price level, the fill ratios, the slippage distribution. Replay that data against your execution logic offline. If your bot cannot survive the worst liquidity snapshot in its replay set, it will not survive live conditions either.
Run your backtests against the actual exchange stream, not synthetic depth. The gap between modeled and real liquidity is where accounts bleed. Your replay harness should reproduce partial fills at the touch, thin top-of-book, and sudden depth withdrawals. Only then does the execution logic earn any trust. π¬
Latency Budget and the Thin-Book Penalty
Every millisecond of delay in a minimum-liquidity market costs you real basis points. The depth is shallow, so any competing flow or market maker adjustment shifts the book before your order lands. Co-locate your execution node close to the exchange's matching infrastructure, or accept the penalty. Use persistent HTTP connections, pipeline your reads where the protocol allows, and eliminate serialization bloat in your order payload. A lean JSON body beats a verbose one every time the connection is warm.
Instrument your round-trip latency at the 95th and 99th percentiles, not the average. Thin markets are where tail latency kills. A bot whose p99 order latency drifts past 400 milliseconds in a low-liquidity selection is effectively trading blind, and the matching engine will happily fill it at whatever price the remaining depth dictates.
Cap your exposure per market to a hard fraction of available depth β no more than 25 percent of the visible size at your price ceiling β and enforce it in code before the request leaves your process.