# The Betfair API 5-second delay, explained

> Why a Betfair delayed application key returns late prices and leaves out traded volume, what a live key needs, and when the delay matters for a pre-match build.

Published 1 July 2026 · updated 5 November 2026

**The "Betfair API 5 second delay" people report comes from Betfair's delayed application key, which returns exchange prices late on purpose. Only a live key, on a funded account that bets through it, removes the delay.** Betfair grants live keys on its own terms, so no change to your code gets you past it.

## Why does the Betfair API return delayed data?

The delay comes from the application key, not from a bug in your code. Betfair gives each developer account two keys, a delayed one for building and testing and a live one, and the delayed key is the one that works straight away. If your prices trail the Betfair website and the gap keeps changing, you are almost certainly reading on a delayed key.

The "5 seconds" quoted in forum threads is second-hand. Betfair's developer support pages describe the delayed key's prices as snapshots with a variable delay, anywhere from about a second to a few minutes, and Betfair sets that length and can change it. Build as if the exact number is unknown. Betfair's own docs carry the current terms.

## Delayed application key vs live application key

The endpoints are the same on both keys. What comes back differs. Betfair says the delayed key also leaves out traded volume (`totalMatched`) and the full ladder of offers (`EX_ALL_OFFERS`), so a build that reads either sees gaps until it moves to a live key.

|  | Delayed application key | Live application key |
| --- | --- | --- |
| Price data | Returned on a delay | Undelayed |
| Traded volume and full ladder | Not returned | Returned |
| How you get it | Issued with a developer account | Granted by Betfair on its own terms |
| Suits | Development, and pre-match reads where the delay is tolerable | Betting applications, including in-play |

The split as Betfair documents it. Check Betfair's developer docs for the current terms.

Polling harder or retrying faster changes nothing, because the price left Betfair late. A live key has a condition too. Betfair's support pages say reading data on a live key without betting through it is not permitted and can lead to restrictions, up to the key being switched off, and that a live key on an unfunded account returns delayed data.

## When the delay matters

It depends on how long a price has to stay right after you read it. Place your product in one of these before you apply for a live key.

- **Pre-match matched betting**: you pair a bookmaker back price with a Betfair lay price before the event starts. Pre-match prices usually move more slowly, so the delay rarely changes which bet qualifies and a delayed key is often workable.
- **Content and comparison**: an odds table or a match preview shows a price the reader acts on later, by hand. A delay of a minute or two rarely shows.
- **In-play**: prices move with every goal, wicket and point, so a delayed key is unusable. This is the case that needs a live key.

For a matched bettor, a delayed lay price costs accuracy. The lay is struck at whatever price the exchange offers when it is placed, so a delayed read means the qualifying loss worked out beforehand is off by however far the price moved. A good tool tells the user to check the exchange before placing, whatever key sits behind it.

If your product is pre-match, the delay is a smaller problem than the one beside it: pairing the lay price to the right back price, with enough money behind it to be real. [How to get Betfair lay odds](https://oddsrelay.io/blog/how-to-get-betfair-lay-odds) covers that in detail.

## One exchange is only part of the lay side

Even with a live key, Betfair alone is not the whole job. A matched bettor wants the best lay against a given back price, and on some events that lay sits on another exchange. Read the [Betfair Exchange](https://oddsrelay.io/bookmakers/betfair-exchange) alone and you will sometimes lay at a worse price than the market offered.

A fuller build reads three exchanges, Betfair, Smarkets and Matchbook, each with its own authentication and response shape. Then every lay price has to be paired to the right bookmaker back price and carry the money available at that price. The delayed key is the first wall you hit. It is far from the last.

## What a matched feed changes

OddsRelay does that pairing before the data reaches you. The feed covers 140+ bookmakers, 60+ of them live in the UK & Ireland, bet365 included, and the standard board pairs bookmaker back prices against lay prices from the same three exchanges. You hold one key and one response shape, and no exchange application key of your own.

Each outcome carries `back` offers, a bookmaker's price, and `lay` offers, an exchange's price with `available`, the money on offer. A lay without enough money behind it is left off the board. The rating and qualifying loss are yours to work out from the two prices, as the code below does and the [oddsmatcher widget](https://oddsrelay.io/widgets/oddsmatcher) does on screen. [Why lay liquidity matters](https://oddsrelay.io/blog/why-lay-liquidity-matters) explains why `available` matters as much as the price.

GET /v2/odds/standard (trimmed to one outcome) · example:

```json
{
  "meta": {
    "region": "uk",
    "odds_format": "decimal",
    "processed_at": "2026-09-20T12:18:11.402Z",
    "last_seen": {
      "william_hill": { "soccer": "2026-09-20T12:18:09Z" },
      "smarkets": { "soccer": "2026-09-20T12:18:07Z" }
    },
    "count": 1,
    "version": "v2",
    "next_cursor": null
  },
  "data": [{
    "event_id": "or_evt_917dd44bce05",
    "commence_time": "2026-09-20T14:00:00Z",
    "home_team": "Arsenal",
    "away_team": "Chelsea",
    "markets": [{
      "key": "h2h",
      "outcomes": [{
        "name": "Arsenal",
        "back": [{ "bookmaker": "william_hill", "price": 2.9, "link": null }],
        "lay":  [{ "exchange": "smarkets", "price": 3.0, "available": 175, "link": null }]
      }]
    }]
  }]
}
```

## Every response dates its prices

A matched feed does not make price age go away. It tells you how old a price can be. Every response carries `meta.processed_at`, the time the board was built. On a matched board, `meta.last_seen` gives the last read for each venue and sport, so now minus `last_seen` is an upper bound on how old that venue's price is.

Your code: rating and price age from the example above · example:

```js
const outcome = board.data[0].markets[0].outcomes[0];
const back = outcome.back[0];
const lay = outcome.lay[0];

// Your arithmetic, not a field in the feed.
const rating = (back.price / lay.price) * 100; // 96.7

// Upper bound on each side's age, in seconds. "soccer" is the sport's group key.
const ageOf = (venue) => (Date.now() - Date.parse(board.meta.last_seen[venue].soccer)) / 1000;
const backAge = ageOf(back.bookmaker);
const layAge = ageOf(lay.exchange);
```

Checking often is cheap. Every data reply carries an `ETag`: send it back as `If-None-Match` and an unchanged board comes back as a `304` that costs no tokens. The [conditional requests guide](https://oddsrelay.io/docs/guides/conditional-requests) shows the loop.

Every product on sale must meet a maximum update time of 10–20 s for match odds, and for every market within six hours of kick-off. That fits pre-match matched betting and comparison. Further from kick-off, prices in the other markets can be older.

Our view: build around the age you can measure, and treat every price as old until its timestamp says otherwise. A product that shows each price's age to the user fails more gracefully than one that assumes speed. The [freshness guide](https://oddsrelay.io/docs/guides/freshness) covers both fields and the sport keys behind `last_seen`.

## Compare the lay side

Check which bookmakers and sports are live right now on the [coverage page](https://oddsrelay.io/coverage), then read the [quickstart](https://oddsrelay.io/docs/guides/quickstart) for the first call.

## Sources

- [Betfair Exchange API documentation: Application Keys](https://betfair-developer-docs.atlassian.net/wiki/spaces/1smk3cen4v3lu3yomq5qye0ni/pages/2687105/Application+Keys), checked 29 September 2026
- [Betfair Developer Program: When should I use the Delayed or Live Application Key?](https://support.developer.betfair.com/hc/en-us/articles/360009638032-When-should-I-use-the-Delayed-or-Live-Application-Key), checked 29 September 2026
- [Betfair Developer Program: What is read-only Betfair API access?](https://support.developer.betfair.com/hc/en-us/articles/25033076334748-What-is-read-only-Betfair-API-access), checked 29 September 2026
- [Betfair Developer Program: Why am I receiving delayed data when using a live Application Key?](https://support.developer.betfair.com/hc/en-us/articles/115003886711-Why-am-I-receiving-delayed-data-when-using-a-live-Application-Key), checked 29 September 2026

18+ · OddsRelay supplies odds data only and takes no bets. Please gamble responsibly.

Source: https://oddsrelay.io/blog/betfair-api-5-second-delay