UFCStats APIufcstats.com ↗
Access UFC event results, fight cards, detailed striking/takedown stats, and fighter profiles from ufcstats.com via a clean JSON API.
What is the UFCStats API?
The UFCStats API covers 5 endpoints that expose completed UFC events, full fight cards, per-round fight statistics, and individual fighter profiles sourced from ufcstats.com. The get_fight_details endpoint alone returns knockdowns, significant strikes broken down by target (head, body, leg, distance, clinch, ground), takedown attempts and successes, control time, referee, judges' scores, and round-by-round breakdowns for both fighters.
curl -X GET 'https://api.parse.bot/scraper/f45724d0-2ef7-41f8-987f-f9440a23e87c/get_events?page=1&limit=5' \ -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 ufcstats-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.
"""UFC Stats API — browse events, drill into fights, search fighters."""
from parse_apis.ufc_stats_api import UFCStats, FighterNotFound
client = UFCStats()
# List recent completed UFC events (limit caps total items fetched).
for event in client.events.list(limit=3):
print(event.name, event.date, event.location)
# Drill into the first event's fight card.
event = client.events.list(limit=1).first()
if event:
detail = event.details()
fight = detail.fights[0]
print(fight.fighter1, "vs", fight.fighter2, "-", fight.method)
# Get detailed stats for that fight.
stats = fight.details()
print(stats.fighter1.name, stats.fighter1.totals.sig_strikes)
print(stats.fighter2.name, stats.fighter2.totals.sig_strikes)
# Search fighters by name and view a profile.
fighter = client.fighters.search(query="Poirier", limit=1).first()
if fighter:
profile = fighter.profile()
print(profile.name, profile.record)
print("Striking accuracy:", profile.stats.striking_accuracy)
for bout in profile.fight_history[:3]:
print(bout.result, "vs", bout.opponent, "-", bout.method)
# Typed error handling: catch a bad fighter ID.
try:
client.fighters.get(fighter_id="0000000000000000")
except FighterNotFound as exc:
print(f"Fighter not found: {exc.fighter_id}")
print("Exercised: events.list / event.details / fight.details / fighters.search / fighter.profile / fighters.get")
Get a paginated list of completed UFC events with name, date, and location. Returns up to `limit` events per page. Paginate with `page`; total pages is included in the response.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number for pagination. |
| limit | integer | Maximum number of events to return per page. |
{
"type": "object",
"fields": {
"page": "current page number",
"events": "array of event objects with event_id, name, date, and location",
"total_pages": "total number of available pages"
},
"sample": {
"data": {
"page": 1,
"events": [
{
"date": "June 06, 2026",
"name": "UFC Fight Night: Muhammad vs. Bonfim",
"event_id": "ba17afef01ed78b6",
"location": "Las Vegas, Nevada, USA"
}
],
"total_pages": 31
},
"status": "success"
}
}About the UFCStats API
Events and Fight Cards
get_events returns a paginated list of completed UFC events — each with an event_id, name, date, and location. Pass page and limit to step through the full event history. Feed any event_id into get_event_details to pull the complete fight card: every bout on the card with fight_id, both fighter names, result, weight class, method of victory, round, time, and a summary of knockdowns, significant strikes, and takedown counts per fighter.
Fight-Level Statistics
get_fight_details goes deeper than the card summary. It exposes fighter totals (knockdowns, significant strikes attempted and landed, total strikes, takedowns, submission attempts, control time) plus a significant_strikes breakdown by zone — head, body, leg, distance, clinch, and ground — for each fighter. The per_round array repeats this full breakdown for every round that was fought. Additional fields include referee, judges (for decision outcomes), time_format, and the exact time and round the fight ended.
Fighter Profiles and Search
search_fighters accepts a partial or full fighter name and returns matching records with fighter_id, nickname, physical attributes (height, weight, reach, stance), and win-loss-draw totals. Pass a fighter_id to get_fighter_details for the complete profile: career averages like strikes landed per minute, striking accuracy, striking defense, takedown accuracy, takedown defense, and submission average, plus a full fight_history array linking back to fight_id and event_id for each bout.
ID Chaining
All five endpoints are designed to chain. get_events → get_event_details → get_fight_details gives a drill-down path from event calendar to per-round punch stats. search_fighters → get_fighter_details → individual fight_id entries in fight_history connect a fighter's career to the raw bout data for every appearance.
The UFCStats API is a managed, monitored endpoint for ufcstats.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when ufcstats.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 ufcstats.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?+
- Build a UFC historical results database keyed on event dates and locations from
get_events. - Compare fighters' significant-strike accuracy and takedown defense before a scheduled bout using
get_fighter_details. - Track how a fighter's striking output per round changes across their career by chaining
fight_historyentries intoget_fight_details. - Populate a fantasy MMA scoring app with live per-round knockdown, strike, and takedown tallies.
- Analyze finish rates by weight class and method of victory across all events from
get_event_details. - Build a fighter search autocomplete backed by
search_fighterspartial-name matching. - Study judge-scoring patterns by aggregating the
judgesfield from split and majority decisions inget_fight_details.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does UFCStats have an official developer API?+
What does `get_fight_details` return beyond what `get_event_details` already shows?+
get_event_details gives summary-level stats per fight: knockdowns, significant strikes, takedowns, submission attempts, method, round, and time. get_fight_details adds the full significant-strike breakdown by target zone (head, body, leg) and position (distance, clinch, ground), control time, referee name, judge scores for decisions, the time format, and a per_round array with all of those stats repeated for every individual round.Does the API cover upcoming or scheduled UFC events?+
get_events returns completed events only. Upcoming fight cards and scheduled bouts are not covered by the current endpoints. You can fork this API on Parse and revise it to add an endpoint targeting scheduled event data.How does pagination work for `get_events`?+
page (integer) and limit (integer) parameters. The response includes page (current page), total_pages (total available), and the events array for that page. Increment page up to total_pages to retrieve the full event history.