# UFC & MMA Data — Fighters, Fight Cards, Stats & Rankings (`foxlabs/ufc-mma-data`) Actor

UFC/MMA data as clean rows: fighter profiles with W-L-D records and finish breakdown, physicals, team and nationality; fight cards with results and both fighters' records; and official rankings by weight class. No API key, no login.

- **URL**: https://apify.com/foxlabs/ufc-mma-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Sports, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 fighter records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## UFC & MMA Data Scraper — Fighters, Fight Cards, Stats & Rankings 🥊

**foXLabs sports data:** UFC/MMA · (Formula 1 · Golf · Cricket · Rugby — coming in the same family)

🎉 Turn UFC and MMA into clean, structured data: fighter profiles with full **W-L-D records**, fight cards with **results**, and official **rankings** by weight class. No API key, no login, no browser setup. Built for sports-betting and DFS modellers, media and stats products, and AI agents.

### 🔍 What is the UFC & MMA Data Scraper — and when should you use it?

Pick a mode and get rows you can filter, export or feed to a model, a spreadsheet or an AI agent:

- **Rankings** — the ranked fighters in every weight class (plus pound-for-pound), each with a full profile and record.
- **Fighters** — the full fighter roster with deep profiles.
- **Events** — fight cards over any date range, with each bout's result and both fighters' records.

**Use it when you need:** a fighter database with records and physicals; historical results to backfill a model; or a live ranking feed for a widget or bot.

**Use something else when** you want other sports' leagues: see the rest of the foXLabs sports family (Formula 1, Golf, Cricket, Rugby).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for it by name: `foxlabs/ufc-mma-data`.

**Your agent can pay for its own runs** — pay-per-event with agentic payments over **x402 (USDC on Base)** or **Skyfire**, with no Apify account of its own. Billing is per delivered record, never for errors or empty results.

Paste into Claude, ChatGPT, Cursor or any MCP assistant:

```
Use the Apify Actor `foxlabs/ufc-mma-data`.
Input: `mode` = rankings | fighters | events; `includeStats` adds career stats;
`dateFrom`/`dateTo` set the range for events; `maxResults` caps rows.
Start with: { "mode": "rankings", "maxResults": 50 }
```

**Things you can ask your agent:**

- "Give me the current men's pound-for-pound top 15 with records."
- "List every lightweight fighter with reach, stance and team."
- "What fights happened last weekend, with results and both fighters' records?"

**Machine-readable output:** every run writes a JSON dataset you can pull from the Apify API or the `.json` dataset endpoint.

### 📋 Overview

The UFC & MMA Data Scraper reads a public, keyless sports data source live on every run and returns deduplicated, camelCase rows. There is nothing to configure: no cookies, no tokens, no proxies to buy.

**Why teams pick this actor:**

- 🧱 **One actor, three jobs** — rankings, fighter roster and fight cards in a single tool.
- 🧬 **Deep profiles, not just scores** — records, physicals, team and headshot, where generic score scrapers stop at the result.
- 🔑 **Zero setup** — no API key, no login, no browser.
- ♻️ **Fresh every run** — reads the source live, so rankings and cards stay current.
- 🤝 **Agent-ready** — MCP + x402, billed per delivered record.

### ✨ Features

- 🏅 **Full records** — W-L-D with wins by KO/submission/decision where published.
- 📇 **Deep profiles** — weight class, height, reach, weight, stance, age, nationality, team, headshot.
- 🗓️ **Fight cards with results** — event, venue, date, both fighters, winner and status.
- 🥇 **Official rankings** — every weight class plus pound-for-pound.
- 📈 **Optional career stats** — striking and grappling splits with `includeStats`.
- 📦 **Clean export** — deduplicated camelCase rows, ready for CSV/Excel/JSON.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~ufc-mma-data/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "rankings", "maxResults": 50}'
```

### 🚀 Getting Started (3 steps)

1. **Pick a mode** — `rankings` for ranked fighters, `fighters` for the full roster, `events` for fight cards.
2. **Set the scope** — `maxResults` to cap rows; `dateFrom`/`dateTo` for events; `includeStats` for career splits.
3. **Run and export** — download the dataset as JSON, CSV or Excel, or pull it from the API.

### 📥 Input

```json
{
  "mode": "rankings",
  "includeStats": false,
  "dateFrom": "2026-10-01",
  "dateTo": "2026-12-01",
  "maxResults": 50
}
```

| Field | Type | Description |
|---|---|---|
| `mode` | string | `rankings` (default), `fighters`, or `events`. |
| `includeStats` | boolean | Add each fighter's career statistics (one extra lookup per fighter). Rankings/fighters modes. |
| `dateFrom` / `dateTo` | string | Event date range (YYYY-MM-DD), events mode. Defaults: last 30 / next 60 days. |
| `maxResults` | integer | Cap on delivered rows (0 = sensible default per mode). |
| `proxyConfiguration` | object | Apify datacenter by default — no setup needed. |

### 📤 Output

**Fighter** (rankings / fighters mode):

```json
{
  "division": "Men's Pound for Pound Rankings",
  "rank": 1,
  "fullName": "Kamaru Usman",
  "nickname": "Nigerian Nightmare",
  "weightClass": "Welterweight",
  "record": { "summary": "21-5-0", "wins": 21, "losses": 5, "draws": 0, "winsBySubmission": 1 },
  "displayHeight": "6' 0\"", "displayReach": "76\"", "displayWeight": "186 lbs", "stance": "Switch",
  "age": 39, "dateOfBirth": "1987-05-11", "nationality": "Nigeria", "team": "Kill Cliff FC",
  "active": true, "headshot": "https://a.espncdn.com/i/headshots/mma/players/full/3088812.png",
  "source": "ESPN", "scrapedAt": "2026-11-02T10:00:00.000Z"
}
```

| Field | Type | Description |
|---|---|---|
| `fullName` | string | Fighter's full name. |
| `nickname` | string | Ring nickname, where published. |
| `division` / `rank` | string / number | Ranking division and position (rankings mode). |
| `weightClass` | string | Primary weight class. |
| `record` | object | `summary` (W-L-D) plus `wins`, `losses`, `draws`, `noContests` and finish splits. |
| `displayHeight` / `displayReach` / `displayWeight` | string | Physicals as published. |
| `stance` | string | Orthodox / Southpaw / Switch. |
| `age` / `dateOfBirth` | number / string | Age and ISO date of birth. |
| `nationality` | string | Citizenship / nationality. |
| `team` | string | Camp or association. |
| `headshot` | string | Portrait image URL. |

**Event** (events mode): `name`, `date`, `venue`, `status`, and `fights[]` — each with both `fighters` (name, record, winner). Every row also carries `source` and `scrapedAt`.

### 💼 Use cases

- **Betting / DFS model**
  - *Input:* `{ "mode": "fighters", "includeStats": true }`
  - *Output:* every fighter with records, physicals and career splits.
  - *Use:* build features; backfill results from `events` mode.
- **Media / stats widget**
  - *Input:* `{ "mode": "rankings" }`
  - *Output:* live rankings per weight class.
  - *Use:* power a leaderboard or "upcoming cards" module.
- **Scouting / analysis**
  - *Input:* `{ "mode": "fighters" }`
  - *Output:* full roster with reach, stance and finish rates.
  - *Use:* compare matchups across a division.

### 🔗 Integration

**JavaScript (Apify client):**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/ufc-mma-data').call({ mode: 'rankings', maxResults: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (Apify client):**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("foxlabs/ufc-mma-data").call(run_input={"mode": "rankings", "maxResults": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**n8n / Zapier / Make:** use the Apify connector, pick this actor, map `mode` and `maxResults`, then route the dataset into your sheet, database or webhook.

### 📊 Pricing

**Pay per result (PPE).** You are billed only for delivered records, never for errors or empty runs.

| Event | Price |
|---|---|
| `fighter` (a profile row, rankings/fighters modes) | $0.004 |
| `event` (a fight card with all bouts) | $0.006 |

A 50-fighter ranking pull costs about $0.20. There is no monthly rental and no minimum.

### ❓ FAQ

#### Do I need an API key or a login to scrape UFC and MMA data?

No. You supply nothing: pick a mode and run. There is no API key to obtain, no account to connect and no browser to configure. The actor reads a public, keyless sports source directly through Apify's free datacenter proxy.

#### What does a fighter row contain?

A fighter's full name and nickname, weight class, the complete win-loss-draw record with finish breakdown (wins by KO, submission and decision where published), physicals (height, reach, weight, stance), age and date of birth, nationality, team, an active flag and a headshot URL. With `includeStats`, career striking and grappling splits are added.

#### How are the three modes different?

`rankings` returns the officially ranked fighters in each weight class plus pound-for-pound; `fighters` returns the full roster with the same deep profiles; `events` returns fight cards over a date range, each bout with both fighters' records and the result.

#### Why is a fighter missing from rankings?

Rankings mode only returns currently ranked fighters (champion plus the division top 15, and pound-for-pound). For an unranked or retired fighter, use `fighters` mode, which covers the full roster.

#### How current is the data?

Every run reads the source live, so rankings, rosters and fight results reflect what the source has published at run time. Results and rankings typically update within hours of an event.

#### Can I get career striking and grappling statistics?

Yes. Turn on `includeStats` in `rankings` or `fighters` mode. Each fighter then carries the published career splits (significant strikes, takedowns, submission attempts and more) as an extra lookup per fighter.

#### Does it cover promotions other than the UFC?

The source centres on the UFC and major MMA; fighters from other promotions appear where the source lists them, with the same fields. Coverage of a given regional promotion depends on what the source publishes.

#### How do I build a fighter database for a model?

Run `fighters` with `includeStats: true` for the full roster with records, physicals and career splits, then run `events` over your date range to attach fight-by-fight results. Join the two on the fighter name or id.

#### Can I export to CSV, Excel or JSON?

Yes. Download the dataset as JSON, CSV or Excel from the Apify console, or pull it straight from the Apify API or the dataset's `.json` endpoint for a pipeline or an AI agent.

#### How is this different from a generic sports-scores scraper?

A generic scraper gives you the event result. This actor gives you the fighters: full records with finish breakdown, physicals, team and rankings — the firmographic depth that betting, DFS and media products need, not just who won.

### 🐛 Troubleshooting

- **Empty result in events mode** — widen `dateFrom`/`dateTo`; the default window is last 30 / next 60 days.
- **A fighter has no career stats** — not every fighter has published splits; the base profile is always present.
- **Fewer rows than `maxResults`** — `maxResults` is a cap, not a target; a mode returns what the source currently has.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to the UFC, Zuffa LLC, ESPN or any promotion. All marks belong to their owners and are used for identification only.

### ⚖️ Is it legal to scrape this data?

This actor reads publicly available, non-personal sports data (fighters, records, results and rankings) that is already published for public viewing. It collects no private or personal data and requires no login. You are responsible for using the output in line with applicable laws and the terms of the sites you rely on. When in doubt, consult a lawyer.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1 — 2026-11-02

- Initial release: rankings, fighters and events modes from a keyless sports API, with full fighter records and profiles.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/ufc-mma-data/changelog.md

# Actor input Schema

## `mode` (type: `string`):

rankings = ranked fighters per weight class (with full profiles); fighters = the full fighter roster; events = fight cards with results over a date range.

## `includeStats` (type: `boolean`):

Fetch each fighter's career striking/grappling statistics (one extra lookup per fighter). Applies to rankings/fighters modes.

## `dateFrom` (type: `string`):

Earliest event date. Defaults to 30 days ago.

## `dateTo` (type: `string`):

Latest event date. Defaults to 60 days ahead.

## `maxResults` (type: `integer`):

Cap on delivered rows (0 = sensible default per mode).

## `concurrency` (type: `integer`):

Parallel ESPN lookups (1-12).

## `proxyConfiguration` (type: `object`):

Leave it on. The Actor reaches ESPN through Apify's free datacenter proxy; no setup is needed. You may switch to residential or your own proxy if you prefer.

## Actor input object example

```json
{
  "mode": "rankings",
  "includeStats": false,
  "maxResults": 50,
  "concurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `report` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "rankings",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/ufc-mma-data").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "rankings",
    "maxResults": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/ufc-mma-data").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "rankings",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call foxlabs/ufc-mma-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/ufc-mma-data"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/h2zZyNYLL8G12wSTQ/builds/ly8JGzUjzGq70yNYy/openapi.json