A practical guide to Betfair Starting Price — how the BSP algorithm works, when to use it, how to place BSP bets via the API, and how to use BSP as a model performance benchmark.
Betfair Starting Price is one of the most misused and least understood features of the exchange. Most recreational punters treat it as a fallback when they can’t be bothered to request a price. Algo traders treat it differently: BSP is a benchmark, a liquidity guarantee, and — used well — a signal for evaluating whether your pre-race model is adding value. Here’s how it actually works.
BSP (Betfair Starting Price) is Betfair’s automated mechanism for matching bets at the point a race goes in-play. It is not the traditional starting price published by bookmakers, which is based on bookmakers’ on-course tissue and board prices. BSP is exchange-derived: it is calculated from the supply and demand of BSP bets in the Betfair market at the moment the race goes off.
The traditional SP is set by bookmakers and reflects their margin. BSP reflects the collective wisdom — or bias — of Betfair customers who have submitted BSP orders. That distinction matters enormously when you’re building a trading strategy.
At the moment the market goes in-play, Betfair runs a matching algorithm across all unmatched BSP orders. The algorithm:
The result is a single price per runner that maximises matched volume. Unmatched BSP orders after this clearing are cancelled. This is fundamentally different from the pre-race order book, where buyers and sellers negotiate explicit prices — BSP orders carry no explicit price, only an optional worst-acceptable-price limit.
| Feature | Traditional SP | Betfair BSP |
|---|---|---|
| Set by | Bookmakers | Exchange matching algorithm |
| Margin | Built in | ~3% Betfair commission |
| Available before race | No (approximate only) | No (exact only at off) |
| Accessible via API | No | Yes |
| Useful as benchmark | Partially | Yes, strongly |
For the algo trader, BSP is the relevant comparison. If your model consistently identifies horses that trade below their BSP in the pre-race market, your model is finding genuine edge. If the pre-race price is systematically above BSP, you’re paying for the privilege of getting on early.
BSP bets are placed using PlaceOrders with betType set to BSP_BACK or BSP_LAY on the LimitOnCloseOrder. Note this is a separate order type from LimitOrder — do not confuse them.
public PlaceExecutionReport placeBspBackBet(
String ssoid, String marketId, long selectionId,
double limitPrice) throws Exception {
// LimitOnCloseOrder = BSP bet with an optional worst-acceptable-price
LimitOnCloseOrder bspOrder = new LimitOnCloseOrder();
bspOrder.setLiability(5.00); // stake for BSP back bet
bspOrder.setPrice(limitPrice); // worst price you'll accept (0 = take any price)
PlaceInstruction instruction = new PlaceInstruction();
instruction.setOrderType(OrderType.LIMIT_ON_CLOSE);
instruction.setSelectionId(selectionId);
instruction.setSide(Side.BACK);
instruction.setLimitOnCloseOrder(bspOrder);
PlaceOrdersRequest request = new PlaceOrdersRequest();
request.setMarketId(marketId);
request.setInstructions(List.of(instruction));
request.setCustomerRef(UUID.randomUUID().toString());
return betfairRestClient.placeOrders(ssoid, request);
}
The price field on LimitOnCloseOrder is a guard, not a target. If you set price to 2.0 on a BSP back, you’re saying “match me at BSP only if BSP is 2.0 or better”. Set it to 1.0 (or 0) and you’re taking whatever BSP emerges. For a layer, the guard works in the opposite direction — it’s the highest price you’re prepared to lay at.
You can submit BSP orders up to one hour before the scheduled start time. They sit in a separate BSP queue and do not appear in the main pre-race order book.
If you want to provide liquidity to BSP backers, you submit a BSP_LAY. Your LimitOnCloseOrder specifies the total liability you’re prepared to accept, and an optional maximum price.
This is useful for market-making strategies: you’re effectively agreeing to take the field against BSP demand. The risk is obvious — if a short-priced favourite has a large BSP backer queue, your liability as a layer could be concentrated on one runner. Always cap your liability explicitly.
This is where BSP earns its keep for systematic traders. After every race, compare your model’s pre-race price against the actual BSP:
public record BspComparison(
long selectionId,
String runnerName,
double modelPrice,
double bsp,
double edgePercent
) {
public static BspComparison of(RunnerResult result, double modelPrice) {
double bsp = result.getBsp();
// Positive edge: model implied probability > BSP implied probability
// i.e. model thinks runner is shorter than BSP says
double modelProb = 1.0 / modelPrice;
double bspProb = 1.0 / bsp;
double edge = (modelProb - bspProb) / bspProb * 100.0;
return new BspComparison(
result.getSelectionId(), result.getName(), modelPrice, bsp, edge
);
}
}
Aggregate edgePercent across hundreds of races. A consistently positive average means your model is identifying selections that BSP undervalues — the exchange market at the off agrees you were right to want them shorter. A consistently negative average means the market is correcting your model’s bias by the time the race goes off.
This analysis is cheap to run post-race and gives you calibration data you can’t easily get from any other source.
One common use of BSP in algo trading is as a guaranteed exit. If you’ve backed a runner pre-race and your position hasn’t fully greened up by the off, submitting a BSP lay means you’ll be matched at the clearing price regardless of what that price turns out to be. You won’t always get the best exit, but you’ll always get out.
Combine this with a pre-race lay ladder strategy: target a specific exit price, and if the market doesn’t reach it, let BSP close the position. You need a model that tells you whether the expected BSP is likely to be above or below your break-even price.
listMarketBook with PriceData.SP_TRADED. Pull them for every settled market you trade and log them alongside your pre-race prices — this is your performance data.If you’re building algo trading systems on the Betfair Exchange API, get in touch.