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 areGETs except placing a bet. - Each address can make 60 requests a minute. Past that you get a
429with aRetry-Afterheader. 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),resolvedandcancelled(voided and refunded). Results and winners arered,blue,tieornull. - Errors come back as
{ "error": { "code", "message" } }. Programs should go by the code:BAD_REQUEST,NOT_FOUNDorRATE_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'sforecast.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 hasopenMatches, 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 (nullif 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 intoslots).
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
pointsIfRightis 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(redorblue),picks(contracts),requestId(your own unique id, like a UUID) and, if you like,minPointsIfRight. Send the samerequestIdto retry safely: the bet is placed once, and the answer saysreplayed. Odds move with every bet, sominPointsIfRightrefuses 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.