# UFC Stats Scraper | MMA Fights and Fighter Data (`parseforge/ufc-stats-scraper`) Actor

Pull UFC fighter stats, fight results, event cards, and round-by-round breakdowns from UFC Stats. Get strikes landed, takedowns, submission attempts, control time, and career records for MMA analytics, fantasy tools, betting models, and combat sports research projects.

- **URL**: https://apify.com/parseforge/ufc-stats-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Sports, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🥊 UFC Stats Scraper

> 🚀 **Export UFC fighter statistics, records, striking accuracy, takedowns, and physical attributes in seconds.** No account, no login, no limits.

> 🕒 **Last updated:** 2026-05-22 · **📊 20 fields** per record · **🥋 4,000+ fighters** · **🌍 Global UFC roster**

Pull the entire UFC fighter database from [ufcstats.com](http://www.ufcstats.com), the official stats source used by analysts, coaches, and MMA media worldwide. Every fighter's record, physical measurements, and advanced striking and grappling metrics are scraped fresh on every run.

The dataset covers all active and retired UFC fighters across all weight classes, from Strawweight to Heavyweight. Each record includes fight record (W-L-D), stance, height, weight, reach, and performance metrics like strikes landed per minute, takedown accuracy, and submission attempts.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| MMA analysts, fantasy MMA players, coaches and trainers, sports journalists, data scientists, sports bettors | Fighter comparison dashboards, fantasy draft research, opponent scouting, data-backed articles, fight outcome modeling, betting research |

---

### 📋 What the UFC Stats Scraper does

- 🔤 **Alphabetical roster scrape.** Pulls the full ufcstats.com roster by last-name letter.
- 📄 **Detail page extraction.** Visits each fighter's profile for extended performance stats.
- 📊 **20 fields per fighter.** Record, physicals, striking, and grappling metrics in one record.
- 🌐 **Public data only.** No login, API key, or credentials needed.
- 🛑 **Clean free tier.** `maxItems` caps free users at 10 fighters with a referral upgrade path.

> 💡 **Why it matters:** ufcstats.com is the official stats engine behind UFC broadcasts. Getting this data programmatically unlocks fighter analytics at scale, comparing 4,000+ athletes across 20 dimensions that would take weeks to collect manually.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>startChar</code></td><td>select</td><td><code>"a"</code></td><td>Starting letter of fighter last name (a-z).</td></tr>
<tr><td><code>scrapeAllLetters</code></td><td>boolean</td><td><code>false</code></td><td>If true, scrapes all 26 letters regardless of <code>startChar</code>.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: fighters starting with J.**

```json
{
    "startChar": "j",
    "maxItems": 50
}
````

**Example: full UFC roster.**

```json
{
    "scrapeAllLetters": true,
    "maxItems": 1000000
}
```

> ⚠️ **Good to Know:** free users are automatically capped at 10 fighters. Upgrade to a paid plan for full roster access. `scrapeAllLetters: true` combined with a high `maxItems` will collect the complete UFC database.

***

### 📊 Output

Each fighter record contains **20 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Description |
|---|---|---|
| 🏷️ `name` | string | Fighter's full name |
| 🔗 `url` | string | Link to ufcstats.com profile |
| 💬 `nickname` | string | Fighter's nickname |
| 📏 `height` | string | Height (e.g. `6' 2"`) |
| ⚖️ `weight` | string | Weight class (e.g. `185 lbs.`) |
| 📐 `reach` | string | Reach in inches (e.g. `76.0"`) |
| 🥋 `stance` | string | Orthodox, Southpaw, or Switch |
| ✅ `wins` | integer | Total career wins |
| ❌ `losses` | integer | Total career losses |
| 🤝 `draws` | integer | Total career draws |
| 🏆 `beltHolder` | boolean | True if current UFC champion |
| 👊 `slpm` | string | Significant strikes landed per minute |
| 🎯 `strikingAccuracy` | string | Striking accuracy percentage |
| 🛡️ `sapm` | string | Significant strikes absorbed per minute |
| 🧱 `strikeDefense` | string | Strike defense percentage |
| 🤼 `takedownAvg` | string | Avg takedowns per 15 minutes |
| 🎯 `takedownAccuracy` | string | Takedown accuracy percentage |
| 🛡️ `takedownDefense` | string | Takedown defense percentage |
| 🐍 `submissionAvg` | string | Avg submissions per 15 minutes |
| 🕒 `scrapedAt` | string | ISO timestamp of collection |
| ❌ `error` | string | null | Error message if collection failed |

#### 📦 Sample record

<details>
<summary><strong>🏆 UFC champion: Jon Jones</strong></summary>

```json
{
    "name": "Jon Jones",
    "url": "http://www.ufcstats.com/fighter-details/07f72a2a7591b409",
    "nickname": "Bones",
    "height": "6' 4\"",
    "weight": "265 lbs.",
    "reach": "84.5\"",
    "stance": "Orthodox",
    "wins": 27,
    "losses": 1,
    "draws": 0,
    "beltHolder": true,
    "slpm": "4.33",
    "strikingAccuracy": "57%",
    "sapm": "2.22",
    "strikeDefense": "64%",
    "takedownAvg": "1.88",
    "takedownAccuracy": "44%",
    "takedownDefense": "95%",
    "submissionAvg": "0.5",
    "scrapedAt": "2026-05-22T01:49:16.025Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🚫 | **No auth required.** Runs immediately, no setup, no API keys. |
| 📊 | **20 fields per fighter.** Record, physicals, and advanced stats in one pass. |
| 🔤 | **Alphabetical filtering.** Target subsets without scraping the whole database. |
| ⚡ | **Fast HTML scraping.** Plain HTML site, no browser overhead. |
| 🔄 | **Real-time data.** Scraped fresh on every run, no stale cache. |
| 🆓 | **Free preview.** 10 fighters free before you upgrade. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Stats depth | Setup |
|---|---|---|---|---|---|
| **⭐ UFC Stats Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **4,000+** fighters | **Live per run** | 20 fields | ⚡ 2 min |
| Manual ufcstats.com export | Free | Full | Manual | Copy-paste | 🐢 Days |
| Official UFC API | Restricted | Partial | Real time | Limited | 🗝️ Auth gated |
| Third-party MMA APIs | Subscription | Varies | Varies | Partial | 🐌 Hours |

Pick this Actor when you want comprehensive fighter stats without partner-API gating.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the UFC Stats Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a `startChar` or enable `scrapeAllLetters`, then set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📊 MMA Analytics Platforms

- Build live fighter comparison engines
- Surface head-to-head stat comparisons
- Power subscriber-only insight dashboards
- Refresh the roster weekly via Apify Schedules

</td>
<td width="50%" valign="top">

#### 🎮 Fantasy MMA Tools

- Automate fighter stat ingestion
- Build scoring models on style metrics
- Reward grappling and striking output
- Surface "value picks" by stance and reach

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Sports Media and Journalism

- Back every fight preview with real data
- Auto-generate matchup comparison tables
- Power pre-event social graphics
- Skip manual stat-checking on PPV weekends

</td>
<td width="50%" valign="top">

#### 🥊 Coaching and Scouting

- Research opponent tendencies pre-camp
- Use TD defense and SLpM for gameplanning
- Track weight-class meta shifts
- Build athlete benchmarking databases

</td>
</tr>
</table>

***

### 🔌 Automating UFC Stats Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor weekly to refresh the full roster after each UFC event.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Sports-science studies of reach vs accuracy
- Career-length analyses across weight classes
- Stance distribution and effectiveness research
- Reproducible MMA datasets for theses

</td>
<td width="50%">

#### 🎨 Personal and creative

- MMA blogs backed by real numbers
- Custom Tapology-style comparison pages
- Discord bots with live fighter lookups
- Personal favorite-fighter trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Combat-sports safety research datasets
- Fighter career-length transparency
- Athletic commission analyses
- Open-data archives for MMA history

</td>
<td width="50%">

#### 🧪 Experimentation

- Train fight outcome classifiers
- Build LLM-powered MMA explainers
- Test card-prediction models
- Prototype fighter recommendation engines

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20UFC%20Stats%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20UFC%20Stats%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20UFC%20Stats%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20UFC%20Stats%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🔑 Does this require a ufcstats.com account?

No. ufcstats.com is fully public. No login or registration is needed.

#### 📦 How many fighters are in the database?

As of 2026, ufcstats.com lists 4,000+ fighters across all weight classes and eras.

#### 🔄 How current is the data?

Data is scraped live on every run. Run it the day after a UFC event to get updated records.

#### 🌐 Can I get all fighters in one run?

Yes. Set `scrapeAllLetters: true` and a high `maxItems` value. This will collect the full roster.

#### 👊 What does SLpM mean?

Significant Strikes Landed per Minute, a measure of offensive output calculated across all UFC bouts.

#### 🛡️ What does SApM mean?

Significant Strikes Absorbed per Minute, how much punishment a fighter takes on average.

#### 🥋 Are retired fighters included?

Yes. ufcstats.com includes all fighters who have ever competed in the UFC, active or retired.

#### 🏆 What is the Belt Holder field?

A boolean indicating whether the fighter is a current UFC champion based on a belt icon on their profile.

#### ⏰ Can I run this on a schedule?

Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run this Actor weekly and keep your dataset current.

#### 📥 What format can I download the data in?

CSV, JSON, Excel (XLSX), XML, or RSS, available directly from the Apify dataset UI.

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

ufcstats.com is a public website with no authentication. Always review the site's terms of service before using scraped data commercially.

#### 🆘 What if I need help?

Our support team is here to help. Use the Tally form linked below to reach out.

***

### 🔌 Integrate with any app

UFC Stats Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe fighter data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes.

***

### 🔗 Recommended Actors

- [**🏎️ Formula 1 Stats Scraper**](https://apify.com/parseforge/formula1-scraper) - F1 standings, race results, and schedules
- [**🏈 ESPN Standings Scraper**](https://apify.com/parseforge/espn-standings-scraper) - NFL, NBA, MLB, NHL, MLS standings
- [**♟️ Chess.com Scraper**](https://apify.com/parseforge/chess-com-scraper) - Chess profiles and ratings
- [**⚾ Baseball Reference Scraper**](https://apify.com/parseforge/baseball-reference-scraper) - MLB historical stats
- [**🏀 Basketball Reference Scraper**](https://apify.com/parseforge/basketball-reference-scraper) - NBA player and team stats

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more sports and reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the Ultimate Fighting Championship (UFC), Zuffa LLC, or TKO Group. All trademarks mentioned are the property of their respective owners. Only publicly available data from ufcstats.com is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `startChar` (type: `string`):

Filter fighters by the first letter of their last name.

## `scrapeAllLetters` (type: `boolean`):

If enabled, scrapes fighters across all 26 letters (ignores Starting Letter). Recommended for building the full UFC fighter database.

## Actor input object example

```json
{
  "maxItems": 10,
  "startChar": "a",
  "scrapeAllLetters": false
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/ufc-stats-scraper").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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ufc-stats-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/ufc-stats-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/ufc-stats-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UFC Stats Scraper | MMA Fights and Fighter Data",
        "description": "Pull UFC fighter stats, fight results, event cards, and round-by-round breakdowns from UFC Stats. Get strikes landed, takedowns, submission attempts, control time, and career records for MMA analytics, fantasy tools, betting models, and combat sports research projects.",
        "version": "0.1",
        "x-build-id": "ANnHdygwTJyUxpA6V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~ufc-stats-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-ufc-stats-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~ufc-stats-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-ufc-stats-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~ufc-stats-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-ufc-stats-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "startChar": {
                        "title": "Starting Letter",
                        "enum": [
                            "a",
                            "b",
                            "c",
                            "d",
                            "e",
                            "f",
                            "g",
                            "h",
                            "i",
                            "j",
                            "k",
                            "l",
                            "m",
                            "n",
                            "o",
                            "p",
                            "q",
                            "r",
                            "s",
                            "t",
                            "u",
                            "v",
                            "w",
                            "x",
                            "y",
                            "z"
                        ],
                        "type": "string",
                        "description": "Filter fighters by the first letter of their last name.",
                        "default": "a"
                    },
                    "scrapeAllLetters": {
                        "title": "Scrape All Letters",
                        "type": "boolean",
                        "description": "If enabled, scrapes fighters across all 26 letters (ignores Starting Letter). Recommended for building the full UFC fighter database.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
