SportsGambler APIsportsgambler.com ↗
Get predicted and confirmed football starting lineups from SportsGambler.com. Covers major worldwide leagues with formations, shirt numbers, and kick-off times.
What is the SportsGambler API?
The SportsGambler Lineups API provides access to football starting lineups across major worldwide leagues via 2 endpoints. Use get_football_lineups to retrieve a list of upcoming matches with lineup availability status, then call get_match_lineup to fetch the full 11-player formation for each team, including shirt numbers and goalkeeper identification. Lineup status is returned as either predicted or confirmed.
curl -X GET 'https://api.parse.bot/scraper/30e9751a-9307-42e6-b454-0747e79e4746/get_football_lineups?league=england-premier-league' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace sportsgambler-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: SportsGambler Football Lineups — browse matches, drill into lineups."""
from parse_apis.sportsgambler_com_api import SportsGambler, InvalidMatchId
client = SportsGambler()
# List upcoming matches with available lineups, capped to 5 items.
for match in client.matches.list(limit=5):
print(f"{match.home_team} vs {match.away_team} — {match.league} ({match.lineup_status})")
# Drill into the first match's detailed lineup.
match = client.matches.list(limit=1).first()
if match is not None:
try:
lineup = match.lineup()
except InvalidMatchId:
print(f"Lineup not available for match {match.match_id}")
else:
print(f"{lineup.home_team.name} ({lineup.home_team.formation})")
for player in lineup.home_team.players:
role = "GK" if player.is_goalkeeper else " "
print(f" {role} #{player.number} {player.name}")
print(f"{lineup.away_team.name} ({lineup.away_team.formation})")
for player in lineup.away_team.players:
role = "GK" if player.is_goalkeeper else " "
print(f" {role} #{player.number} {player.name}")
# Filter by league slug.
for match in client.matches.list(league="england-premier-league", limit=3):
print(f"{match.date} {match.time} — {match.home_team} vs {match.away_team}")
print("exercised: matches.list / match.lineup / league filter")
Returns upcoming football matches that have predicted or confirmed starting lineups available. Results include match identifiers, kick-off times, league names, team names, and whether the lineup is predicted or confirmed. Optionally filter by league using the league slug. Returns all available matches for the current matchday window (typically today and the next few days). One HTTP round-trip per call; no pagination.
| Param | Type | Description |
|---|---|---|
| league | string | League URL slug to filter by (e.g. 'england-premier-league', 'germany-bundesliga', 'spain-la-liga'). Omit to return all leagues. |
{
"type": "object",
"fields": {
"total": "integer count of matches returned",
"matches": "array of match objects with match_id, date, time, league, home_team, away_team, lineup_status"
},
"sample": {
"data": {
"total": 10,
"matches": [
{
"date": "Friday 28 August",
"time": "12:00",
"league": "Premier League",
"match_id": "5795429",
"away_team": "Man City",
"home_team": "Crystal Palace",
"lineup_status": "predicted"
}
]
},
"status": "success"
}
}About the SportsGambler API
Match Discovery
The get_football_lineups endpoint returns an array of upcoming matches that have lineup data available. Each match object includes a match_id, date, time, league name, home_team, away_team, and a lineup_status field indicating whether the lineup is predicted or confirmed. You can optionally pass a league parameter using a URL slug such as england-premier-league, germany-bundesliga, or spain-la-liga to narrow results to a specific competition. Without this filter, matches across all covered leagues are returned together with a total count.
Detailed Lineup Data
The get_match_lineup endpoint accepts a match_id string obtained from get_football_lineups results and returns the full lineup for both sides. Each team object contains the team name, tactical formation (e.g. 4-3-3), and a players array with shirt numbers and goalkeeper identification for all 11 players. The top-level lineup_type field mirrors the status from the discovery endpoint, letting you know whether to treat the selection as a confirmed team sheet or a pre-match prediction.
Coverage and Scope
Coverage spans major football leagues worldwide. The league slug filter makes it straightforward to focus on a single competition without post-filtering on your side. The match_id is numeric and stable within a session, so the two endpoints are designed to be called sequentially: discover matches first, then fetch individual lineups by ID.
The SportsGambler API is a managed, monitored endpoint for sportsgambler.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when sportsgambler.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official sportsgambler.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Pre-match betting research using confirmed starting XI data and formations before placing wagers
- Fantasy football lineup tracking to check player selections across multiple leagues before deadlines
- Building a lineups dashboard that flags when a predicted lineup transitions to confirmed status
- Aggregating formation data across leagues to analyze tactical trends by team or competition
- Alerting system that monitors
lineup_statuschanges from predicted to confirmed for specific matches - Odds modeling pipelines that incorporate player availability and formation as input features
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does SportsGambler.com have an official developer API?+
How do I filter lineups by a specific league?+
league parameter to get_football_lineups using the league's URL slug, such as england-premier-league or spain-la-liga. Omitting the parameter returns matches across all covered leagues. The endpoint returns a total integer alongside the matches array so you can see how many results came back for the given filter.What is the difference between a predicted and a confirmed lineup?+
lineup_type field (returned by get_match_lineup) and the lineup_status field (returned by get_football_lineups) both carry either predicted or confirmed. A predicted lineup is an expected team selection published before official confirmation; a confirmed lineup reflects the officially announced starting XI. Both states include the full 11 players, formation, and shirt numbers.Does the API return historical lineups or post-match data such as substitutions?+
Are player-level statistics or injury status included in the lineup response?+
players array within each team object returns shirt numbers and goalkeeper identification, but does not include individual player statistics, injury flags, or market values. You can fork the API on Parse and revise it to pull additional player-level data from a complementary source.