API

Lovat Bet has a free JSON API for bots, dashboards and spreadsheets: events, every match's odds, how they moved, alliance selection markets and playoff brackets. Reading needs no account or key. With a key from Settings, a program can also bet on matches with your own points.

Basics

  • Every endpoint is under https://lovat.bet/api/v1. All are GETs except placing a bet.
  • Each address can make 60 requests a minute. Past that you get a 429 with a Retry-After header. Answers can be up to 5 seconds old, so there's no point asking more often than that.
  • Any website can read the public data from the browser (CORS is open). Nothing in it names a player.
  • Times are ISO 8601 in UTC, and dates are YYYY-MM-DD. Chances run from 0 to 1, and Blue's is 1 − chanceRed. Team numbers are strings, since some offseason teams have letters (6418B).
  • Statuses are pending, open, closed (betting is over, the result isn't in), resolved and cancelled (voided and refunded). Results and winners are red, blue, tie or null.
  • Errors come back as { "error": { "code", "message" } }. Programs should go by the code: BAD_REQUEST, NOT_FOUND or RATE_LIMITED, and for bets the ones below.
  • Fields may be added, but none will change or disappear under /api/v1. A breaking change would come as /api/v2.

Endpoints

/config
The game's settings: pickCost (points per contract), the market maker's forecast.liquidity, the stake caps and timing, and the old, unused limits for parlays, which were removed (combos), alliance selection and the bracket's points per round.
/events?when=live|upcoming|past&q=
Events, searched by name, key or city if you give q. Live means within a day of its dates. Each has openMatches, how many of its matches take bets right now.
/events/{eventKey}
One event: its teams with their rank and record, every match with its market, whether it has alliance selection markets, and the bracket challenge's status.
/matches?status=open|closed
Every match taking bets (or closed and waiting for its result) across all events, soonest to close first. This is the one to poll.
/matches/{matchKey}
One match and its history: Red's chance at opening and after each bet, oldest first.
/events/{eventKey}/alliances
Alliance selection markets: each team's chance of joining each alliance (allianceChances[0] is Alliance 1) or of not being picked, and once resolved, the alliance it joined (null if it wasn't picked).
/events/{eventKey}/bracket
The playoff bracket challenge: the alliances, the bracket's 14 slots with the points a right pick scores, and the winning alliance of each slot so far. A slot's sides come from a seed ({ "seed": 1 }) or from the winner or loser of an earlier slot ({ "winnerOf": 0 }, an index into slots).

Betting through the API

Make a key in Settings and send it with each request as Authorization: Bearer <key>. You see a key once, when you make it, and can revoke it there. Anyone with your key can bet your points, so keep it out of web pages and shared code. Only single match bets work through the API: parlays were removed, and alliance selection and brackets stay on the site.

  • A 10% fee. A winning bet placed through the API pays 10% of its profit (what it pays less what it cost) as a fee, and you keep the other 90%. The fee is rounded and fixed when you place the bet. The quote and the placed bet show it, and pointsIfRight is always after the fee. Losing and refunded bets cost nothing extra.
  • Marked on the site. Bets placed through the API carry an API label in the match's recent bets and in your points history, and once you've placed one, your name carries it on the leaderboards.
  • The site's rules. One side per match, at most 2,000 points on a match and 400 contracts in a bet, and 10 bets every 10 seconds across the site and the API together.
/matches/{matchKey}/quote?side=red|blue&picks=
What a bet of that many contracts would get right now through the API: its cost, what it pays after the fee, the fee, and Red's chance after it. No key needed.
POST /matches/{matchKey}/picks
Place a bet. Send JSON: side (red or blue), picks (contracts), requestId (your own unique id, like a UUID) and, if you like, minPointsIfRight. Send the same requestId to retry safely: the bet is placed once, and the answer says replayed. Odds move with every bet, so minPointsIfRight refuses a bet that would now pay less.
/me
Your username, balance and open bets on matches that aren't decided yet.

A refused bet comes back with one of these codes: UNAUTHORIZED (401: no key, or an unknown or revoked one), CLOSED or CHANCE_MOVED (409), NOT_ENOUGH_POINTS, LIMIT, OTHER_SIDE or INVALID (422), and RATE_LIMITED (429). In Python:

import os, uuid, requests

API = "https://lovat.bet/api/v1"
KEY = os.environ["LOVAT_BET_KEY"]  # made in Settings; keep it secret
auth = {"Authorization": f"Bearer {KEY}"}

m = requests.get(f"{API}/matches").json()["matches"][0]
q = requests.get(f"{API}/matches/{m['key']}/quote", params={"side": "red", "picks": 10}).json()
r = requests.post(
    f"{API}/matches/{m['key']}/picks",
    headers=auth,
    json={
        "side": "red",
        "picks": 10,
        "requestId": str(uuid.uuid4()),  # resend the same one to retry safely
        "minPointsIfRight": q["pointsIfRight"],  # refuse a worse price
    },
)
print(r.status_code, r.json())

OpenAPI

The API is described in OpenAPI 3.1 at https://lovat.bet/api/v1/openapi.json, every field included. Load it into Swagger Editor, Postman or Insomnia to try the endpoints, or generate a typed client with OpenAPI Generator.

A match

A match's forecast is its market, or null before it has one. picks is how many bets it has, and pointsRed and pointsBlue the points bet on each side. openingSource says where the opening odds came from: scouting (Lovat's scouting data), statbotics, default (50/50) or replay.

{
  "key": "2026cc_qm12",
  "eventKey": "2026cc",
  "label": "Qual 12",
  "compLevel": "qm",
  "red": ["254", "1678", "6418B"],
  "blue": ["971", "4414", "1323"],
  "time": "2026-09-19T18:42:00.000Z",
  "redScore": null,
  "blueScore": null,
  "winner": null,
  "forecast": {
    "status": "open",
    "chanceRed": 0.613,
    "openingChanceRed": 0.58,
    "openingSource": "scouting",
    "closesAt": "2026-09-19T18:37:00.000Z",
    "result": null,
    "picks": 14,
    "pointsRed": 310,
    "pointsBlue": 95
  }
}

Working out a payout

The odds come from a market maker whose prices depend only on the current chance and its liquidity b (forecast.liquidity, 500). A bet of s points on a side at chance p pays round(b × ln((e^(s/b) − 1 + p) / p)) if that side wins, the same as the bet ticket shows. Through the API, take off the fee: round(0.1 × (pays − s)). In Python:

import math, requests

API = "https://lovat.bet/api/v1"
b = requests.get(f"{API}/config").json()["forecast"]["liquidity"]

for m in requests.get(f"{API}/matches").json()["matches"]:
    p = m["forecast"]["chanceRed"]
    s = 50  # points: 10 contracts
    pays = round(b * math.log((math.exp(s / b) - 1 + p) / p))
    print(m["eventKey"], m["label"], f"Red {p:.0%}: {s} points pay {pays}")

Fair play

Scripts may bet only through the API, with a key from your own account. Automating the website itself, sharing a key or hammering the API breaks the terms. You can always place a bet your program suggests yourself, on the site: that's an ordinary bet, with no fee and no API label.