# Sherdog Scraper - MMA Fighter Records, Fights & Events (`bovi/sherdog-scraper`) Actor

Scrape Sherdog.com MMA data: fighter records with KO/submission/decision breakdowns, full bout-by-bout fight history (pro and amateur), and full event cards including upcoming fights. Search by fighter URL, name, event, weight class or gym.

- **URL**: https://apify.com/bovi/sherdog-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Other, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.20 / 1,000 sherdog scraper - mma fighter records, fights & events

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

## Sherdog Scraper - MMA Fighter Records, Fights & Events

Scrape public MMA data from [Sherdog.com](https://www.sherdog.com), the sport's largest fight database. It covers every promotion: UFC, Bellator, PFL, ONE, RIZIN, KSW, LFA and the regional shows. No login and no API key are needed. Export the results as JSON, CSV, Excel or XML, or read them through the Apify API.

### What it collects

You choose one of two row shapes with the **What to return** setting:

- **Fights**: one row per bout. Each row has the opponent and both Sherdog profile URLs, the result from the fighter's side (`win`, `loss`, `draw`, `no contest`, `upcoming`) and `pro` or `amateur`. It also has the event name, URL and ISO date, the method split into `method` and `methodDetail` (for example `TKO` and `Spinning Back Kick and Punches`), and a `methodCategory` bucket (KO/TKO, Submission, Decision, Other). Then come `isFinish`, the referee, the round, the time and `timeSeconds`, plus `fightNumber` (career order) and `daysSincePreviousFight`. Rows read from an event page also carry the promotion, the venue, city, region and country, the weight class, the match number on the card, and main-event and title-fight flags. Event-card rows include the fighter records shown on the card where Sherdog lists them.
- **Fighter profiles**: one row per fighter. Each row has the name, nickname, nationality, birthplace, birth date, age, height and weight in both unit systems, division, and every gym listed. It also has wins, losses, draws and no contests, broken down by KO/TKO, submission, decision and other. Each row also includes finish, KO, submission, decision and win rates, the current streak, debut and last-fight dates, days since the last fight, the pro and amateur fight counts, and the announced next fight when Sherdog lists one.

Fields Sherdog does not show for a fighter or bout are left out of the row. The scraper never guesses them.

### Input

| Field | What it does |
| --- | --- |
| `fighterUrls` | Sherdog fighter URLs, e.g. `https://www.sherdog.com/fighter/Jon-Jones-27944`. This is the most reliable input. |
| `fighterNames` | Full names, resolved through Sherdog's Fight Finder by exact match. |
| `eventUrls` | Event URLs. The whole card is scraped, and upcoming cards work too. |
| `weightClass`, `association` | Narrow a name search, or on their own browse every fighter in a division or gym. |
| `resultType` | `fights` (one row per bout) or `fighters` (one row per profile). |
| `includeAmateurFights` | Include or skip the amateur record. |
| `dateFrom`, `dateTo`, `resultFilter`, `methodFilter`, `organizationFilter`, `titleFightsOnly`, `finishesOnly` | Filters applied before saving. Filtered-out rows are never written. |
| `maxResults` | Maximum number of rows saved in total (default 50). |
| `proxyConfiguration` | Optional Apify Proxy. Sherdog normally works without it. |

### Example output (Fights)

```json
{
  "fighter": "Jon Jones",
  "fighterUrl": "https://www.sherdog.com/fighter/Jon-Jones-27944",
  "fighterId": "27944",
  "opponent": "Stipe Miocic",
  "opponentUrl": "https://www.sherdog.com/fighter/Stipe-Miocic-39537",
  "result": "win",
  "fightType": "pro",
  "eventName": "UFC 309 - Jones vs. Miocic",
  "eventUrl": "https://www.sherdog.com/events/UFC-309-Jones-vs-Miocic-103896",
  "eventDate": "2024-11-16",
  "method": "TKO",
  "methodDetail": "Spinning Back Kick and Punches",
  "methodCategory": "KO/TKO",
  "isFinish": true,
  "referee": "Herb Dean",
  "round": 3,
  "time": "4:29",
  "timeSeconds": 269,
  "fightNumber": 30,
  "source": "fighter"
}
```

### Price per result

The Actor is priced per dataset item: you pay a small fixed fee for every row saved to the dataset (one fight or one fighter profile). The current price per 1,000 results is shown on the Actor's pricing tab. Rows removed by a filter are never saved, so you are never charged for them. Use `maxResults` to cap the cost of a run.

### Notes

- Sherdog marks title fights only on event cards, so `titleFightsOnly` needs an event URL.
- Sherdog does not record a referee for every bout, mostly amateur and older regional fights. Those rows have no `referee` field.
- The data is public Sherdog data. Use it in line with Sherdog's terms and the laws that apply to you.

# Actor input Schema

## `fighterUrls` (type: `array`):

Sherdog fighter profile URLs, e.g. https://www.sherdog.com/fighter/Jon-Jones-27944. This is the most reliable input — Sherdog identifies a fighter by the number at the end of the URL.

## `fighterNames` (type: `array`):

Full fighter names to look up in Sherdog's Fight Finder, e.g. "Amanda Nunes". Only an exact full-name match is used (the first one Sherdog lists). The full name is searched first, then the surname as a fallback — pass the fighter URL when you already have it.

## `eventUrls` (type: `array`):

Sherdog event URLs, e.g. https://www.sherdog.com/events/UFC-309-Jones-vs-Miocic-103896. The whole card is scraped, including the main event and every undercard bout. Works for upcoming events too.

## `weightClass` (type: `string`):

Limit the Fight Finder search to one division. On its own, with no fighter name, it browses every fighter Sherdog lists in that division.

## `association` (type: `string`):

Limit the search to one team. Sherdog matches this as a partial name, so "American Top Team" also returns its affiliates. On its own it browses every fighter listed with that team.

## `resultType` (type: `string`):

"Fights" returns one row per bout — the full fight history of each fighter and every bout on each event card. "Fighter profiles" returns one row per fighter, with the career record and method breakdown; in this mode an event URL means "every fighter on this card", which costs one request per fighter.

## `includeAmateurFights` (type: `boolean`):

Sherdog lists amateur bouts in a separate table from the pro record. Turn this off to return professional bouts only. Applies to the "Fights" result type.

## `maxSearchPages` (type: `integer`):

How many 20-result Fight Finder pages to read when resolving a name by surname or browsing a weight class / gym. The full name is tried first, which usually needs one page.

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

YYYY-MM-DD. Filters on the event date. Rows excluded by a filter are never saved.

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

YYYY-MM-DD. Filters on the event date.

## `resultFilter` (type: `array`):

Keep only bouts with these results, from the fighter's point of view. Leave empty for all.

## `methodFilter` (type: `array`):

Sherdog writes the method free-form ("TKO (Spinning Back Kick and Punches)"). Every value is also bucketed into one of these four so you can filter on it. Leave empty for all.

## `organizationFilter` (type: `string`):

Case-insensitive partial match, e.g. "UFC", "Bellator", "PFL". A fighter's history table has no promotion column, so this matches the event name there — which is where the promotion appears.

## `titleFightsOnly` (type: `boolean`):

Sherdog marks title bouts on event cards only, never in a fighter's history table, so this needs at least one event URL. The run fails with that message rather than returning an empty dataset.

## `finishesOnly` (type: `boolean`):

Keep only bouts that ended by KO/TKO or submission. Decisions, DQs and no contests are dropped.

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

Maximum number of rows to save, counted across every source.

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

Optional. Sherdog usually works without a proxy; turn on Apify Proxy if your runs get blocked.

## Actor input object example

```json
{
  "fighterUrls": [
    "https://www.sherdog.com/fighter/Jon-Jones-27944"
  ],
  "fighterNames": [
    "Amanda Nunes"
  ],
  "eventUrls": [
    "https://www.sherdog.com/events/UFC-309-Jones-vs-Miocic-103896"
  ],
  "weightClass": "",
  "association": "American Top Team",
  "resultType": "fights",
  "includeAmateurFights": true,
  "maxSearchPages": 25,
  "dateFrom": "2015-01-01",
  "dateTo": "2024-12-31",
  "resultFilter": [],
  "methodFilter": [],
  "organizationFilter": "UFC",
  "titleFightsOnly": false,
  "finishesOnly": false,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with the scraped rows.

# 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 = {
    "fighterUrls": [
        "https://www.sherdog.com/fighter/Jon-Jones-27944"
    ],
    "resultType": "fights",
    "includeAmateurFights": true,
    "maxSearchPages": 25,
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/sherdog-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 = {
    "fighterUrls": ["https://www.sherdog.com/fighter/Jon-Jones-27944"],
    "resultType": "fights",
    "includeAmateurFights": True,
    "maxSearchPages": 25,
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/sherdog-scraper").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 '{
  "fighterUrls": [
    "https://www.sherdog.com/fighter/Jon-Jones-27944"
  ],
  "resultType": "fights",
  "includeAmateurFights": true,
  "maxSearchPages": 25,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/sherdog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bovi/sherdog-scraper"
        }
    }
}
```

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/46CGpZ8YaKihp3AYd/builds/n7njJ4hVP0xVAIF4b/openapi.json