Live now!
Live Score API

Every goal on screen before your users refresh.

Live match state, goals, cards, substitutions and lineups from 2,200+ football leagues, in one uniform response. Built to hold its shape on the night everyone opens your app at once.

No contracts, no minimums First call in minutes 99.99% measured uptime
GET /v3/football/livescores?include=events;statistics;participants 200 OK
Eredivisie · 26 Oct 2025FT
Feyenoord crestFeyenoord
2 - 3
PSVPSV crest

Events

30'Ismael Saibari assist Mauro Júnior0-1
50'Luciano Valente assist Givairo Read1-1
51'Ismael Saibari assist Guus Til1-2
60'Ismael Saibari1-3
73'Oussama Targhalline2-3
48%Ball possession52%
One real Eredivisie fixture. Every minute, name and number on this card comes from the call above.

Trusted by 30,000+ sports builders

Case study
Case study
Case study
Case study
Case study Case study ScoutsLand Case study Case study Case study Sportspoule Case study Case study Case study Last5Games Case study Case study
2,200+
football leagues
99.99%
uptime
6.4B
API requests per month
10 years
of sports data, at scale
What actually breaks livescore products

Three ways a live feed loses you the user

Livescore is an unforgiving category. The product is judged on the worst thirty seconds of the busiest night, not on the average.

The 89th minute arrives late

A user who hears the goal on the street before it lands in your app does not come back to check whether it was a one-off. Freshness is not a nice-to-have in this category, it is the entire product.

Events carry the real minute, the scorer and the assist

Peak nights behave differently

Plenty of feeds are fine on a Tuesday and wobble when eight matches kick off together and your traffic triples. The load you need to survive is the one you cannot schedule around.

6.4B API requests a month, at 99.99% measured uptime

Coverage thins where users care

Every provider carries the big five. Your retention comes from the second tier and the league someone follows because they grew up near the ground. That is where budget feeds quietly stop.

2,200+ leagues, one response shape across all of them

From token to live scores

Three requests, and your scoreboard is live

No SDK to adopt and no schema to design first. These are real calls against the v3 API, with the include options that decide how much comes back.

01

Ask what is in play

One request returns every fixture live right now, across every competition on your plan. This is the call your matchday loop makes.

GET200
// every match currently in play
/v3/football/livescores/inplay
  ?include=participants;events;periods
  &api_token=YOUR_TOKEN

Useful includes

participantsperiodsstatescores
02

Narrow it to your competitions

Filter the same endpoint down to the leagues your product covers, so you are not paying for and parsing matches your users will never see.

GET200
// 72 = Eredivisie
/v3/football/livescores/inplay
  ?include=participants;events.type
  &filters=fixtureLeagues:72

Useful includes

events.typeleaguevenueround
03

Go deep on one fixture

When a user opens a match, request that fixture with the heavier includes. Same ids and same response shape, so the detail view reuses your list-view parser.

GET200
// one fixture, full detail
/v3/football/fixtures/19429278
  ?include=events;statistics;
  lineups.player;participants

Useful includes

eventsstatisticsxGFixture
The data behind a livescore product

What you will actually be calling

Not a capability list. These are the endpoints a livescore build hits on matchday, and the fields they return, named exactly as they appear in the response.

EndpointWhat it gives youFields you will use
/livescoresEverything in play, right now The matchday spine. One call returns every live fixture rather than making you loop over a schedule and check each one. idnamestate_idstarting_atleague_id
/fixturesBefore and after the whistle Schedules, results and the full history of a match. Same ids and same response shape as the live feed, so one renderer covers both. result_infovenue_idperiods[].minutescores[]
include=eventsGoals, cards, substitutions Every incident with its real minute and the players involved, plus the running score after it. This is what a timeline renders from. minuteextra_minuteplayer_namerelated_player_nameresult
include=lineupsWho is on the pitch Starting elevens, bench and formation slots, with player ids you can key your own records against. player_idplayer_namejersey_numberformation_field
include=statisticsThe match in numbers Bilateral team statistics, one object per team per type, so a stats panel is a loop rather than a special case per competition. type_idlocationdata.value
/standingsWhere it leaves the table Live and end-of-round tables for every covered competition, so the table on your league page moves when the match does. positionpointsparticipant_iddetails[]

Scroll the table sideways to see every column.

Every field above is in the free trial. Read the full entity reference →

Developer experience

From token to live scores in one session

One endpoint, the includes you name, and a response that looks the same in every competition. Here is the call and exactly what comes back.

# Every fixture that is live right now
curl -s "https://api.sportmonks.com/v3/football/livescores?include=participants;events" \
  -H "Authorization: YOUR_API_TOKEN"
const res = await fetch(
  "https://api.sportmonks.com/v3/football/livescores?include=participants;events",
  { headers: { Authorization: process.env.SPORTMONKS_TOKEN } }
);
const { data } = await res.json();

for (const fixture of data) {
  console.log(fixture.name, fixture.state_id);
  fixture.events.forEach(e =>
    console.log(e.minute, e.player_name, e.result)
  );
}
import os, requests

r = requests.get(
    "https://api.sportmonks.com/v3/football/livescores",
    params={"include": "participants;events"},
    headers={"Authorization": os.environ["SPORTMONKS_TOKEN"]},
    timeout=10,
)

for fixture in r.json()["data"]:
    print(fixture["name"], fixture["state_id"])
    for e in fixture["events"]:
        print(e["minute"], e["player_name"], e["result"])
$ch = curl_init(
  "https://api.sportmonks.com/v3/football/livescores?include=participants;events"
);
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => ["Authorization: " . getenv("SPORTMONKS_TOKEN")],
]);

$body = json_decode(curl_exec($ch), true);
foreach ($body["data"] as $fixture) {
    printf("%s (state %d)\n", $fixture["name"], $fixture["state_id"]);
}
req, _ := http.NewRequest("GET",
  "https://api.sportmonks.com/v3/football/livescores?include=participants;events", nil)
req.Header.Set("Authorization", os.Getenv("SPORTMONKS_TOKEN"))

res, err := http.DefaultClient.Do(req)
if err != nil {
    return err
}
defer res.Body.Close()

var payload LivescoreResponse
json.NewDecoder(res.Body).Decode(&payload)
Sample response · Feyenoord 2-3 PSV 200 OK
{
  "data": [
    {
      "id": 19429278,
      "league_id": 72,
      "season_id": 25597,
      "venue_id": 1795,
      "name": "Feyenoord vs PSV",
      "starting_at": "2025-10-26 13:30:00",
      "result_info": "PSV won after full-time.",
      "participants": [
        { "id": 73,  "name": "Feyenoord",
          "meta": { "location": "home" } },
        { "id": 682, "name": "PSV",
          "meta": { "location": "away" } }
      ],
      "events": [
        { "minute": 30, "type_id": 14, "participant_id": 682,
          "player_name": "Ismael Saibari",
          "related_player_name": "Mauro Júnior",
          "result": "0-1" },
        { "minute": 50, "type_id": 14, "participant_id": 73,
          "player_name": "Luciano Valente",
          "related_player_name": "Givairo Read",
          "result": "1-1" },
        { "minute": 51, "type_id": 14, "participant_id": 682,
          "player_name": "Ismael Saibari",
          "related_player_name": "Guus Til",
          "result": "1-2" },
        { "minute": 60, "type_id": 14, "participant_id": 682,
          "player_name": "Ismael Saibari", "result": "1-3" },
        { "minute": 62, "type_id": 19, "participant_id": 682,
          "player_name": "Sergiño Dest" },
        { "minute": 73, "type_id": 14, "participant_id": 73,
          "player_name": "Oussama Targhalline", "result": "2-3" }
        // + 10 more events (substitutions through 90+2')
      ],
      "statistics": [
        { "type_id": 45, "location": "home", "data": { "value": 48 } },
        { "type_id": 45, "location": "away", "data": { "value": 52 } },
        { "type_id": 42, "location": "home", "data": { "value": 12 } },
        { "type_id": 42, "location": "away", "data": { "value": 11 } },
        { "type_id": 80, "location": "home", "data": { "value": 422 } },
        { "type_id": 80, "location": "away", "data": { "value": 465 } }
        // + 35 more statistic types on this fixture
      ]
    }
  ]
}

Same shape in the Eredivisie, the Premier League and a second division you have never heard of. Read the docs or get a token and run it yourself.

Proof for the vendor review

The numbers a technical evaluator will ask you for

Every figure here is measured rather than marketed, and we say which is which.

6.4B
API requests per month
Proven at peak-event volume, so a full European midweek behaves like a quiet Monday.
99.99%
Measured uptime
Our own observed availability. Ask support for the service terms that apply to your plan.
2,200+
Football leagues
Including the second tiers and regional competitions your retention actually depends on.
10 years
In production
A decade of serving sports data at scale, and a vendor still here to support what you build.

Measured uptime is our own observed availability, not a contractual guarantee. Ask support for the service terms that apply to your plan.

Builders shipping live data on this feed

What live actually feels like in production

Club fan app · Dinamo Zagreb
★★★★★
"It's incredibly fast, and you always know what to expect. The API's uniform and clear responses provide assurance that your data fetching engine will handle everything smoothly."

ShiftOneZero builds the official Dinamo Zagreb fan app on real-time match data, and rates Sportmonks support 10 out of 10. Uniform responses matter most when the same renderer has to survive every fixture in every competition you carry.

Josip Bozic Josip BožićCEO and Lead Developer, ShiftOneZero

"The data is fast and consistent, which is critical for live features."

Leon Korsters

Leon KorstersCo-founder, Sportspoule

"The data updates in real-time, which is crucial for our platform, as our game mechanics depend on precise and up-to-date stats."

Nicolo Mazzoni

Nicolò MazzoniStarcks

Read the full case studies →

Pricing

Published prices, no contracts, no minimums

Start on the free tier, move up when your traffic does. Every plan includes the livescores endpoint, human support and a 14-day trial of the paid features.

Starter

For a first build

EUR29/mo

Billed monthly

  • 5 leagues of your choice
  • 2,000 API calls per hour
  • Livescores, fixtures, events, lineups
  • Human support, seven days a week
Start free

Growth

Most livescore builds start here

EUR99/mo

Billed monthly

  • 30 leagues of your choice
  • 2,500 API calls per hour
  • Everything in Starter
  • Room for a real matchday audience
Start free

Pro

Multi-league portals

EUR249/mo

Billed monthly

  • 120 leagues of your choice
  • 3,000 API calls per hour
  • Everything in Growth
  • Add-ons attach to the same plan
Start free

Enterprise

Full coverage

from EUR499/mo

Billed monthly

  • All 2,200+ leagues
  • 5,000 API calls per hour, custom limits
  • Everything in Pro
  • A named personal contact
Talk to our team

Prices exclusive of VAT. League counts are how many competitions you select on that plan, not a limit on what the API covers. See the full plan comparison →

Live Score API, FAQ

What builders ask before they integrate

Quick answers before you take a token. The long version is in the developer docs.

How do I get every match that is live right now?

One call to the livescores endpoint. It returns every fixture currently in play, with whichever includes you name on the query string, so you do not have to fetch a schedule first and then check each fixture individually.

Add include=events for goals and cards, include=lineups for the elevens, include=statistics for the team numbers. Every entity is listed in the docs.

How often can I poll the livescores endpoint?

Your plan sets an hourly rate limit per entity, starting at 2,000 calls an hour on Starter and rising through the tiers. Most livescore products poll on a fixed interval during matches and back off outside them.

If you are unsure what your matchday pattern will cost you, ask support before you build around a number. The limit per tier is on the plans and pricing page.

How do I tell half time from stoppage time?

Every fixture carries a state, and the periods object carries the running minute, so you read the match state rather than inferring it from a clock.

Events also carry an extra_minute field, which is how added time is expressed rather than folding it into the minute itself.

Which leagues are covered live?

Sportmonks covers 2,200+ football leagues, and the live feed follows that coverage. What varies is depth inside a fixture: a lower-tier competition may return scores and events without lineups or the full statistic set.

Check the competition on the coverage page before you build a match page around it.

What happens when a score is corrected?

Feeds are cross-checked against more than one source rather than taken from a single upstream, which is what keeps a bad value from becoming a bad scoreline in your app.

When a correction does happen, the fixture and its events update in place under the same ids, so your next poll returns the corrected state without you reconciling anything.

Do I need an add-on for live scores?

No. Livescores, fixtures, events, lineups and team statistics are core Football API data, available on every plan including the free tier. Nothing on this page needs an add-on.

The extra analytical layers are sold separately and are listed on the plans and pricing page.

Can I use the widgets instead of building a front end?

Yes. The livescore widgets run on this same feed and drop into a page with an embed, which is often the faster route if the live view is one part of a bigger product rather than the product itself.

You can start with a widget and move to the API later without changing data provider.

Ready when you are

Pull a live match, then decide.

A token takes a couple of minutes and needs no card. Call the livescores endpoint, look at what comes back, and judge the feed on the response rather than on this page.

No contracts, no minimums. Human support seven days a week, including during your trial.

Sportmonks is the most approachable sports data API. Reliable enough to trust in production, priced so you can start today, and built so one person can get it working in an afternoon.

Building something else?