# Sherdog MMA Fighter Records Scraper (`automation-lab/sherdog-mma-fighter-records`) Actor

Extract public Sherdog fighter profiles, career records, and normalized fight histories with opponents, results, events, methods, rounds, times, and dates.

- **URL**: https://apify.com/automation-lab/sherdog-mma-fighter-records.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.52 / 1,000 fighter or fight rows

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/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 MMA Fighter Records Scraper

Refresh **Sherdog MMA fighter records** and fight histories as structured data.
Give the Actor exact fighter names or public Sherdog fighter URLs and receive
normalized fighter and bout rows in the default Apify dataset.

Each fight row can include the opponent, result, event, method, referee, round,
time, and date exposed on the source profile. Fighter rows include source
identity, nationality, birthplace, measurements, association, weight class,
and career totals when Sherdog displays them.

### What does this Actor do?

The Actor supports two targeting routes:

1. resolve an exact fighter name through Sherdog Fight Finder; or
2. fetch a precise `sherdog.com/fighter/...` profile URL.

It parses Sherdog's public server-rendered pages. JavaScript rendering, login,
and a paid proxy are not required for the current workflow.

The default output combines:

- one `fighter` row per requested profile; and
- one `fight` row per professional bout displayed on that profile.

Use the filters to return only fight rows, selected outcomes, or fights on and
after a date. This makes the same Actor useful for one-time research and small
recurring record-refresh jobs.

### Who is it for?

Use this Actor if you are:

- a sports researcher maintaining MMA career-record datasets;
- an analyst comparing opponents, methods, rounds, and event history;
- a publisher preparing sourced fighter timelines;
- a developer feeding public MMA records into a database or notebook;
- an operations team scheduling recurring checks for changed fight histories.

For UFCStats-specific event and strike statistics, use our related UFCStats
Actor instead. This Actor is intentionally centered on Sherdog's broader MMA
fighter profiles and the fields Sherdog publicly exposes.

### Why use it?

Sherdog profile pages are readable, but repeated manual copy-and-paste is slow
and inconsistent. This Actor provides:

- stable source IDs and canonical profile URLs;
- separate fighter and fight entity rows;
- ISO `YYYY-MM-DD` dates where source dates can be parsed;
- exact-name discovery with ambiguity protection;
- an overall output cap and fighter cap;
- date and result filters applied consistently;
- clear failures for unsupported URLs and unexpected source pages.

Name lookup never silently substitutes a partial match. If an exact normalized
name cannot be resolved, supply the fighter's profile URL.

### What data can I extract?

| Field | Available on | Meaning |
| --- | --- | --- |
| `recordType` | all rows | `fighter` or `fight` |
| `fighterId` | all rows | Stable numeric ID from the Sherdog URL |
| `fighterName` | all rows | Displayed fighter name |
| `fighterNickname` | all rows | Nickname when shown |
| `fighterUrl` | all rows | Canonical Sherdog profile URL |
| `nationality`, `birthplace` | all rows | Public identity/location fields |
| `birthDate`, `age` | all rows | Public age fields when shown |
| `height`, `weight` | all rows | Displayed imperial/metric measurements |
| `association`, `weightClass` | all rows | Team/gym and current class |
| `wins`, `losses`, `draws`, `noContests` | all rows | Career totals when exposed |
| `result` | fight rows | `win`, `loss`, `draw`, or `nc` |
| `opponent`, `opponentUrl` | fight rows | Opponent identity and profile |
| `event`, `eventUrl` | fight rows | Event title and Sherdog event URL |
| `method`, `referee` | fight rows | Result method and referee when shown |
| `round`, `time`, `date` | fight rows | Ending round/time and event date |
| `scrapedAt` | all rows | Collection timestamp |

Fields unavailable on the source are returned as `null`. Fighter context is
repeated on fight rows so each row remains useful in spreadsheets and data
warehouses without a separate join.

### How to get started

1. Open the Actor in Apify Console.
2. Keep the prefilled Jon Jones profile URL or replace it with another public
   Sherdog fighter URL.
3. Alternatively, remove `startUrls` and add one or more exact
   `fighterNames`.
4. Choose whether to include fighter rows, fight rows, or both.
5. Optionally set `fromDate` or `fightResults`.
6. Set `maxFighters` and `maxItems` to bound the run.
7. Click **Start**.
8. Open the default dataset or export it as JSON, CSV, Excel, XML, or RSS.

The prefilled input is intentionally small and works without credentials.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | Jon Jones URL in prefill | Exact public Sherdog fighter URLs |
| `fighterNames` | string array | `[]` | Exact names resolved through Fight Finder |
| `includeProfile` | boolean | `true` | Include one fighter row per profile |
| `includeFightHistory` | boolean | `true` | Include professional fight rows |
| `fightResults` | string array | `[]` | Optional `win`, `loss`, `draw`, `nc` filter |
| `fromDate` | string | unset | Keep fights on/after this `YYYY-MM-DD` date |
| `maxFighters` | integer | `10` | Maximum profiles, from 1 to 50 |
| `maxItems` | integer | `100` | Maximum combined output rows, from 1 to 5,000 |

At least one URL or name is required. At least one of `includeProfile` and
`includeFightHistory` must be enabled.

### Example inputs

Find a fighter by exact name:

```json
{
  "fighterNames": ["Islam Makhachev"],
  "maxFighters": 1,
  "maxItems": 20
}
```

Fetch one exact profile and only recent fight rows:

```json
{
  "startUrls": [
    { "url": "https://www.sherdog.com/fighter/Jon-Jones-27944" }
  ],
  "includeProfile": false,
  "includeFightHistory": true,
  "fromDate": "2020-01-01",
  "maxItems": 20
}
```

Collect only losses and no contests:

```json
{
  "startUrls": [
    { "url": "https://www.sherdog.com/fighter/Jon-Jones-27944" }
  ],
  "fightResults": ["loss", "nc"],
  "includeProfile": false,
  "maxItems": 50
}
```

### Output example

A normalized fight row has this shape:

```json
{
  "recordType": "fight",
  "fighterId": "27944",
  "fighterName": "Jon Jones",
  "fighterNickname": "Bones",
  "fighterUrl": "https://www.sherdog.com/fighter/Jon-Jones-27944",
  "nationality": "United States",
  "wins": 28,
  "losses": 1,
  "result": "win",
  "opponent": "Stipe Miocic",
  "opponentUrl": "https://www.sherdog.com/fighter/Stipe-Miocic-39537",
  "event": "UFC 309 - Jones vs. Miocic",
  "eventUrl": "https://www.sherdog.com/events/UFC-309-Jones-vs-Miocic-103896",
  "method": "TKO (Spinning Back Kick and Punches)",
  "referee": "Herb Dean",
  "round": 3,
  "time": "4:29",
  "date": "2024-11-16",
  "scrapedAt": "2026-09-15T06:00:00.000Z"
}
```

The exact values can change when Sherdog updates a fighter profile.

### How much does it cost to extract Sherdog fighter records?

Pay-per-event pricing has two parts:

- **$0.005** once when a valid run starts; and
- one `item` event for each fighter or fight row saved.

The BRONZE item price is **$0.0092**. The six active item tiers are:

| Tier | Price per saved row |
| --- | ---: |
| FREE | $0.01058 |
| BRONZE | $0.0092 |
| SILVER | $0.007176 |
| GOLD | $0.00552 |
| PLATINUM | $0.00552 |
| DIAMOND | $0.00552 |

At BRONZE, calculate an example Actor charge as the **$0.005** start fee
plus the saved row count multiplied by **$0.0092**. For example, use
`0.005 + (10 × 0.0092)` for 10 rows or `0.005 + (100 × 0.0092)` for 100 rows.

Rows rejected by filters, duplicate profile URLs, failed requests, and empty
results are not charged as items. Apify platform compute charges are handled
according to your Apify plan.

### Scheduling record monitoring

Create one task per tracked fighter group and schedule it weekly or after an
expected event. Keep stable input and export each run's dataset to your own
storage. Compare rows by a composite key such as:

```text
fighterId + date + opponentUrl + eventUrl
```

A newly appearing key usually represents a newly listed bout. A changed method,
result, or date can indicate a source correction. This Actor returns snapshots;
it does not send alerts or maintain a cross-run history database for you.

### Data pipeline patterns

Common workflows include:

- schedule → dataset → Google Sheets;
- webhook → database upsert keyed by fighter and bout;
- dataset API → pandas or an analytics notebook;
- Make/Zapier flow → Slack notification for new rows;
- recurring run → object storage snapshot → diff job.

Use `recordType` to route fighter and fight rows into separate destination
tables if your pipeline uses a normalized relational model.

### Run through the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~sherdog-mma-fighter-records/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"fighterNames":["Islam Makhachev"],"maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sherdog-mma-fighter-records').call({
  fighterNames: ['Islam Makhachev'],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/sherdog-mma-fighter-records").call(
    run_input={"fighterNames": ["Islam Makhachev"], "maxItems": 20}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/sherdog-mma-fighter-records"
```

#### Claude Desktop, Cursor, and VS Code

Use this HTTP MCP configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/sherdog-mma-fighter-records"
    }
  }
}
```

Example prompts:

- “Fetch Islam Makhachev's current Sherdog record and summarize finish methods.”
- “Export Jon Jones fights since 2020 as structured rows.”
- “Compare the latest saved fighter totals with last week's snapshot.”

The assistant receives the same typed default-dataset rows as API users.

### Reliability and limits

The Actor uses public server-rendered Sherdog pages and performs requests
sequentially. Transient network errors, HTTP 429, and server errors receive a
small bounded retry. Stable invalid URLs and unsupported pages fail directly.

Important limits:

- only `sherdog.com/fighter/...` profile URLs are accepted;
- name discovery requires an exact normalized match;
- Fight Finder lookup inspects at most ten result pages per name;
- only the professional fight-history table is exported;
- values absent on Sherdog remain `null`;
- the Actor does not calculate rankings, odds, or strike statistics;
- upstream markup or access-policy changes can require an update.

A valid no-result filter run succeeds with zero rows. A blocked or malformed
source page is treated as an error, not as an empty result.

### Troubleshooting

#### Why was my fighter name not found?

Sherdog may list a different spelling, punctuation, or duplicate name. Open the
public Sherdog profile and provide its exact URL in `startUrls`.

#### Why is a field null?

Sherdog does not expose every field for every fighter or historical bout. Null
means the value was unavailable on the profile at collection time.

#### Why did I receive fewer rows than expected?

Check `maxItems`, `fromDate`, and `fightResults`. The overall item cap applies
after filters and includes fighter rows when `includeProfile` is enabled.

#### Does the Actor need a proxy?

No. The current implementation uses direct public HTTPS. It does not silently
switch to a residential proxy, so there is no hidden proxy-transfer cost.

### Responsible use and legality

This Actor extracts public information from public Sherdog pages. You are
responsible for ensuring that your use complies with applicable laws,
Sherdog's terms, intellectual-property rights, database rights, and Apify's
policies.

Collect only what you need. Avoid aggressive schedules, do not use the output
to harass or profile people unfairly, and preserve source attribution where
appropriate. Public availability does not remove all reuse restrictions.

### Frequently asked questions

#### Can I request several fighters?

Yes. Combine names and URLs and set `maxFighters` up to 50. Duplicate canonical
profile URLs are fetched once.

#### Are amateur fights included?

No. Version 0.1 exports the professional fight-history table only.

#### Can I return only fight rows?

Yes. Set `includeProfile` to `false` and keep `includeFightHistory` enabled.

#### Can I filter by opponent or event?

Not in version 0.1. Filter the resulting dataset downstream, or use the result
and date filters before collection.

#### Does it enrich opponent profiles?

No. Opponent names and profile URLs are included from each fight row, but the
Actor does not fetch each opponent recursively.

### Related automation-lab Actors

- [UFC Events, Fights & Fighters](https://apify.com/automation-lab/ufc-events-fights-fighters)
  for UFCStats events, bouts, fighter profiles, and available bout statistics.
- [ESPNcricinfo Statsguru Scraper](https://apify.com/automation-lab/espncricinfo-statsguru-scraper)
  for a comparable repeatable sports-record workflow in cricket.

These Actors use different sources and output contracts. Choose the source that
matches your research question rather than treating records as interchangeable.

### Support

If a public Sherdog fighter page works in a browser but the Actor fails, include
an example profile URL, run link, and the relevant error message in an Actor
issue report. Do not include API tokens or private data.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/sherdog-mma-fighter-records/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Public sherdog.com/fighter/... profile URLs. Use URLs to target a precise fighter or disambiguate duplicate names.

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

Exact public fighter names to resolve through Sherdog Fight Finder, such as Islam Makhachev. Use profile URLs for ambiguous names.

## `includeProfile` (type: `boolean`):

Emit one fighter row with identity, measurements, affiliation, weight class, and career totals per profile.

## `includeFightHistory` (type: `boolean`):

Emit one normalized row for each professional fight shown on the fighter profile.

## `fightResults` (type: `array`):

Optional result filter applied to fight-history rows. Leave empty to include wins, losses, draws, and no contests.

## `fromDate` (type: `string`):

Optional YYYY-MM-DD date. Older fight rows are excluded; fighter profile rows are unaffected.

## `maxFighters` (type: `integer`):

Maximum number of distinct fighter profiles to fetch across URLs and names.

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

Maximum combined fighter and fight rows saved to the default dataset.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.sherdog.com/fighter/Jon-Jones-27944"
    }
  ],
  "fighterNames": [],
  "includeProfile": true,
  "includeFightHistory": true,
  "fightResults": [],
  "maxFighters": 10,
  "maxItems": 20
}
```

# Actor output Schema

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

Fighter identity, career record, and fight-history rows from this run.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.sherdog.com/fighter/Jon-Jones-27944"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sherdog-mma-fighter-records").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 = {
    "startUrls": [{ "url": "https://www.sherdog.com/fighter/Jon-Jones-27944" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sherdog-mma-fighter-records").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 '{
  "startUrls": [
    {
      "url": "https://www.sherdog.com/fighter/Jon-Jones-27944"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/sherdog-mma-fighter-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/sherdog-mma-fighter-records"
        }
    }
}
```

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/OY7EwsBWHyi9T0dIB/builds/wgsg5y1aKP3YlgY02/openapi.json