# UFC Scraper (`solidcode/ufc-scraper`) Actor

\[💰 $30 / 1K] Extract UFC fighters, events, and rankings: athlete profiles, win-loss records, striking and grappling stats, full fight cards with results, and official division and pound-for-pound rankings. Search by name or collect everything.

- **URL**: https://apify.com/solidcode/ufc-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 144 total users, 47 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## UFC Scraper

Pull official UFC data at scale — fighter profiles and career records, complete event fight cards with results, and the live rankings for every weight division. One structured input covers fighters, events, and rankings, with optional deep career stats on demand. Built for MMA journalists, sports-betting analysts, and fantasy-MMA and fan-stats app builders who need a clean, structured UFC dataset without clicking through hundreds of athlete and event pages by hand.

### Why This Scraper?

- **Three data types in one actor** — switch a single dropdown between Fighters (athlete profiles), Events (fight cards and results), and Rankings (official division standings). No endpoint strings to memorize.
- **Every official rankings list in one run** — all 13 that UFC publishes today: 8 men's and 3 women's weight classes plus men's and women's Pound-for-Pound, each returned with its reigning champion and up to 15 ranked contenders, including each contender's rank-movement arrow. The set follows UFC's official rankings page, so if a division is retired or added your runs track it automatically.
- **Up to ~18 career stat fields per fighter when available** — striking accuracy, significant strikes landed/absorbed per minute, takedown accuracy and defense, submission averages, and win-method breakdowns (by KO/TKO, submission, and decision), pulled straight from the athlete profile. Coverage is best-effort: most fighters return a full stat block, some return a partial set or none if their profile omits it.
- **Full fight cards with verified results** — every bout's red- and blue-corner fighter, and for completed events the winner, finish method (KO/TKO, Submission, Decision), round, and exact end time.
- **Title-fight and bonus flags** — each fight is tagged when it's a championship bout, and post-fight performance awards are captured when present.
- **Filter by status, country, and division** — narrow fighters to Active, Not currently fighting, or Retired, by place of birth (e.g. Brazil, Russia, United States), and by any of the 13 division filters (8 men's, 4 women's, plus Pound-for-Pound).
- **Search by exact fighter or event name** — pass names like "Jon Jones" or "UFC 300" and each term is resolved and merged automatically; leave it blank to sweep the entire roster or event calendar.
- **Upcoming and past events** — collect the full future calendar, completed events with final results, or both in a single run.
- **Win-loss-draw records split into numbers** — every fighter's record arrives as a clean string plus separate `wins`, `losses`, and `draws` integers, ready to sort and chart.

### Use Cases

**Sports Media & Journalism**

- Build fight-week preview tables with both athletes' full records and stats
- Pull the current champion of every division for ranking-update articles
- Track main-card and prelim matchups as event lineups are announced
- Compile finish-method breakdowns for fighter feature pieces

**Betting & Odds Analysis**

- Feed historical win method, round, and end-time data into handicapping models
- Compare striking and takedown differentials between matched opponents
- Backtest finish-rate trends by division and fighter status
- Monitor upcoming cards to line up markets ahead of opening odds

**Fantasy & Fan Apps**

- Power fantasy-MMA scoring with per-fighter records and career stats
- Keep an app's roster fresh with active-fighter profiles and images
- Surface live division rankings and champion changes to users
- Build head-to-head comparison tools from structured fighter fields

**Research & Data Science**

- Assemble a complete fighter database with hometown, division, and status
- Analyze finish rates and title-fight outcomes across the event archive
- Study the geographic spread of the roster by country of birth
- Map rank movement over time across every ranked division

**Talent & Matchmaking Analytics**

- Identify ranked contenders by division and competitive status
- Track which prospects are climbing the rankings each update
- Profile a division's depth from champion down to the 15th contender

### Getting Started

#### Look up one fighter

```json
{
  "dataType": "fighters",
  "searchTerms": ["Jon Jones"]
}
```

#### Current rankings for one division

```json
{
  "dataType": "rankings",
  "division": "lightweight"
}
```

#### Upcoming events with full fight cards

```json
{
  "dataType": "events",
  "eventType": "upcoming",
  "includeDetails": true,
  "maxResults": 10
}
```

#### Active heavyweights from the United States

```json
{
  "dataType": "fighters",
  "division": "heavyweight",
  "fighterStatus": "active",
  "country": "United States",
  "maxResults": 50
}
```

### Input Reference

#### What to Extract

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `dataType` | string | `"fighters"` | What to collect: `fighters` (athlete profiles & records), `events` (fight cards & results), or `rankings` (official division & pound-for-pound standings). |
| `searchTerms` | array | `[]` | Fighter names (for Fighters) or event names (for Events). Each term is searched separately and results are merged. Leave empty to collect everything of the chosen type. Ignored for Rankings. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `division` | string | `""` (all) | Limit to one weight division: `flyweight`, `bantamweight`, `featherweight`, `lightweight`, `welterweight`, `middleweight`, `light-heavyweight`, `heavyweight`, the four `womens-*` classes, or `pound-for-pound`. Applies to Fighters and Rankings. A Fighters run reads the whole roster to find every athlete in the division, so allow a few minutes and set `maxResults` above the division's size. Sizes differ widely: roughly 500 athletes at Lightweight, 8 at Women's Featherweight. `womens-featherweight` returns Fighters only for now: UFC no longer publishes a Women's Featherweight ranking, so Rankings has no list to return for it. |
| `gender` | string | `""` (all) | Limit to `male` or `female` divisions. Applies to Fighters and Rankings, with or without `includeDetails`. A fighter's gender comes from their weight division, and the roster isn't sorted by gender, so a women-only Fighters run reads the whole roster to find them (women are roughly one athlete in nine) — allow a few minutes and set `maxResults` to suit. |
| `fighterStatus` | string | `""` (any) | Limit to `active`, `not-fighting`, or `retired`. Applies to Fighters only. |
| `country` | string | `""` | Limit to fighters born in this country, e.g. `United States`, `Brazil`, `Russia`. Applies to Fighters only. |
| `eventType` | string | `"all"` | Collect `upcoming` events, `past` events, or `all`. Applies to Events only. |

#### Output Detail & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `true` | Fetch the complete record per result: striking/grappling stats and bio for fighters, or the full fight card with per-fight results for events. Turn off for a faster, lighter listing-level summary. No effect on Rankings. |
| `maxResults` | integer | `100` | How many records to collect in total across all search terms. You'll get at most this many — fewer when the source has fewer (Rankings always returns one row per division regardless of this value). Set to `0` to collect everything available, but `0` is not unlimited: every run also carries its own results limit, taken from the **Maximum results** or spend limit in the run's options, and the smaller of the two wins. Left untouched, that limit usually stops an uncapped sweep at a few hundred rows, and the run tells you exactly where it stopped and why. Raise the run's Maximum results (or spend limit) before starting to collect more. Very large uncapped sweeps are also time-budgeted — Fighters roster runs (with or without full details) and Events calendar runs alike. If a run reaches the budget it stops and returns the records gathered so far, with a note in the log — set a specific number, or narrow with a weight division or event type, for a run that finishes cleanly. |

### Output

The actor returns three record types, distinguished by the `recordType` field. Each is described below.

#### Fighter (`recordType: "fighter"`)

```json
{
  "recordType": "fighter",
  "id": "jon-jones",
  "name": "Jon Jones",
  "nickname": "Bones",
  "division": "Heavyweight",
  "gender": "male",
  "status": "Active",
  "record": "28-1-0",
  "wins": 28,
  "losses": 1,
  "draws": 0,
  "hometown": "Rochester, New York, United States",
  "city": "Rochester, New York",
  "country": "United States",
  "height": "76.00",
  "weight": "248.00",
  "reach": "84.00",
  "legReach": "45.00",
  "age": "37",
  "octagonDebut": "Aug. 9, 2008",
  "trainsAt": "Jackson Wink MMA",
  "stats": {
    "Sig. Str. Landed Per Min": "4.30",
    "Takedown Accuracy": "44%",
    "Wins by Knockout": "10",
    "Wins by Submission": "7"
  },
  "image": "https://www.ufc.com/images/...",
  "url": "https://www.ufc.com/athlete/jon-jones"
}
```

**Core Fields**

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"fighter"`. |
| `id` | string | Stable fighter identifier (athlete slug). |
| `name` | string | Full fighter name. |
| `nickname` | string | Ring nickname, when one exists. |
| `division` | string | Weight division, e.g. "Heavyweight". |
| `gender` | string | `male` or `female`, taken from the athlete's weight division. Empty when UFC lists no division for them. |
| `status` | string | Active, Not currently fighting, or Retired. |
| `url` | string | UFC.com athlete profile URL. |
| `image` | string | Profile photo URL, or empty when UFC.com has no photo on file. |

**Record & Bio**

| Field | Type | Description |
|-------|------|-------------|
| `record` | string | Win-loss-draw string, e.g. "28-1-0". |
| `wins` / `losses` / `draws` | integer | Record split into numbers. |
| `hometown` | string | Full place of birth. |
| `city` | string | City portion of the hometown. |
| `country` | string | Country of birth. |
| `height` / `weight` / `reach` / `legReach` | string | Physical measurements. |
| `age` | string | Fighter age. |
| `octagonDebut` | string | Date of first UFC appearance. |
| `trainsAt` | string | Training gym / camp. |
| `stats` | object | Striking, grappling, takedown, and win-method stats (best-effort, when `includeDetails` is on). Keys mirror the labels shown on UFC.com and may vary by fighter. |

#### Event (`recordType: "event"`)

```json
{
  "recordType": "event",
  "id": "ufc-300",
  "title": "UFC 300: Pereira vs Hill",
  "date": "2024-04-13T22:00:00Z",
  "location": "Las Vegas, Nevada, USA",
  "poster": "https://www.ufc.com/images/...",
  "fightCount": 13,
  "fights": [
    {
      "weightClass": "Light Heavyweight Title Bout",
      "isTitleFight": true,
      "redCorner": { "name": "Alex Pereira", "url": "https://www.ufc.com/athlete/alex-pereira" },
      "blueCorner": { "name": "Jamahal Hill", "url": "https://www.ufc.com/athlete/jamahal-hill" },
      "redOutcome": "Win",
      "blueOutcome": "Loss",
      "winner": "Alex Pereira",
      "method": "KO/TKO",
      "round": "1",
      "time": "3:14",
      "awards": ["Performance of the Night"]
    }
  ],
  "url": "https://www.ufc.com/event/ufc-300"
}
```

**Event Fields**

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"event"`. |
| `id` | string | Stable event identifier (event slug). |
| `title` | string | Event headline, e.g. "UFC 300: Pereira vs Hill". |
| `date` | string | Event date in ISO 8601 (UTC). |
| `location` | string | Venue city, region, and country. |
| `poster` | string | Event poster image URL. |
| `fightCount` | integer | Number of bouts on the card. |
| `fights` | array | The full fight card (see below). |
| `url` | string | UFC.com event URL. |

**Each item in `fights`**

| Field | Type | Description |
|-------|------|-------------|
| `weightClass` | string | Weight class / bout label. |
| `isTitleFight` | boolean | True when it's a championship bout. |
| `redCorner` / `blueCorner` | object | Fighter `name` and profile `url` per corner. |
| `redOutcome` / `blueOutcome` | string | Win / Loss / Draw per corner (past events). |
| `winner` | string | Winning fighter's name (past events). |
| `method` | string | Finish method: KO/TKO, Submission, or Decision. |
| `round` | string | Round the fight ended. |
| `time` | string | Time within the final round. |
| `awards` | array | Performance / Fight of the Night bonuses, when present. |

#### Ranking (`recordType: "ranking"`)

```json
{
  "recordType": "ranking",
  "id": "lightweight",
  "division": "Lightweight",
  "gender": "male",
  "championName": "Islam Makhachev",
  "champion": {
    "name": "Islam Makhachev",
    "url": "https://www.ufc.com/athlete/islam-makhachev"
  },
  "rankings": [
    { "rank": 1, "name": "Arman Tsarukyan", "url": "https://www.ufc.com/athlete/arman-tsarukyan", "change": "+1" },
    { "rank": 2, "name": "Charles Oliveira", "url": "https://www.ufc.com/athlete/charles-oliveira", "change": "-1" }
  ],
  "url": "https://www.ufc.com/rankings"
}
```

**Ranking Fields**

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"ranking"`. |
| `id` | string | Stable division key, e.g. `lightweight`, `womens-strawweight`. |
| `division` | string | Division name, or "Pound-for-Pound". |
| `gender` | string | `male` or `female`. |
| `championName` | string | Reigning champion's name, as a plain text field. |
| `champion` | object | Reigning champion's `name` and profile `url`. |
| `rankings` | array | Ranked contenders, each with `rank`, `name`, `url`, and a rank-movement `change`. |
| `url` | string | UFC.com rankings URL. |

### Tips for Best Results

- **Use Rankings for the fastest division snapshot** — a single Rankings run returns the current champion and top-15 contenders for every division at once, no search terms needed.
- **Turn off `includeDetails` for a quick roster sweep**, then re-run with specific fighter names and details on to pull deep stats only for the athletes you care about — faster and lighter than enriching the whole roster. Deep stats are best-effort, so a name-by-name run gives the most complete stat coverage for the fighters that matter to you.
- **Pair a country or status filter with a weight division** — these filters check each athlete's profile, so combining them with a division narrows the search and returns fuller results faster.
- **Pass exact, common name spellings** in `searchTerms` (e.g. "Sean O'Malley", "Israel Adesanya") so each fighter resolves on the first try.
- **Set `eventType` to `past`** to mine completed events for winners, finish methods, rounds, and end times — the result fields only populate for events that have already happened.
- **Check the run's own Maximum results before an uncapped sweep** — `maxResults: 0` asks for everything, but each run carries its own results limit in the run options and the smaller number wins, so an untouched limit can stop a full roster or calendar sweep at a few hundred rows. Raise it first, or give `maxResults` a real number: a capped run finishes cleanly every time, while an uncapped one can also reach the run's time budget and come back partial (the log says so either way).
- **Sweeping one weight division? Give it room** — the roster isn't ordered by division, so the run reads all of it to find every athlete in your division, and division sizes range from roughly 500 at Lightweight down to 8 at Women's Featherweight. Set `maxResults` above the division's size, or to `0`, so a big division isn't cut short.
- **Filter by `gender`** to return just the men's or women's side, on Rankings or on Fighters, in one pass.

### Pricing

**From $30.00 per 1,000 results** — undercuts comparable UFC data tools while returning a richer, ready-to-use structure. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $3.60 | $3.39 | $3.19 | $3.00 |
| 1,000 | $36.00 | $33.90 | $31.90 | $30.00 |
| 10,000 | $360.00 | $339.00 | $319.00 | $300.00 |
| 100,000 | $3,600.00 | $3,390.00 | $3,190.00 | $3,000.00 |

A "result" is one record pushed to your dataset — one fighter, one event, or one division's ranking. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available information from UFC.com for research, analytics, and editorial use. Use the data responsibly and in compliance with applicable laws, the source site's terms of service, and relevant data-protection regulations. You are responsible for how you use the collected data, including any redistribution. Do not use it to harass individuals or for any unlawful purpose.

# Actor input Schema

## `dataType` (type: `string`):

Choose the kind of UFC data you want. Fighters returns athlete profiles and records. Events returns fight cards and results. Rankings returns the official UFC rankings by weight division and pound-for-pound.

## `searchTerms` (type: `array`):

Names or keywords to search for. Use fighter names (e.g. "Jon Jones") when extracting Fighters, or event names (e.g. "UFC 300") when extracting Events. Each term is searched separately and results are merged. Leave empty to collect everything of the chosen type. Ignored for Rankings.

## `division` (type: `string`):

Only include fighters or rankings from this weight division. Leave as "All divisions" to include every division. Applies to Fighters and Rankings. The UFC roster isn't sorted by division, so a Fighters run reads the whole roster to find every athlete in the division you picked — allow a few minutes for it, and raise Max results above the division's size (or set it to 0) so nothing is cut off. Divisions vary a lot in size: Lightweight has around 500 athletes while Women's Featherweight has only 8, so a small division genuinely returns a short list. Note: Pound-for-Pound is a rankings list, not a roster weight class, so it only narrows Rankings — for Fighters it returns the full roster. Women's Featherweight is a Fighters-only option right now — UFC no longer publishes a Women's Featherweight ranking, so Rankings has no list to return for it until the division is ranked again.

## `gender` (type: `string`):

Limit results to men's or women's divisions. Leave as "All" for both. Applies to Fighters and Rankings. A fighter's gender comes from their weight division, so on Fighters this narrows the list whether or not you ask for full details. The roster isn't sorted by gender, so a women-only Fighters run reads through the whole roster to find them (women are roughly one athlete in nine) — allow a few minutes and raise Max results, or set it to 0, so nothing is cut off. Athletes UFC lists with no weight division at all can't be placed on either side, so they're left out when this is set.

## `fighterStatus` (type: `string`):

Only include fighters with this competitive status. Leave as "Any" to include everyone. Applies to Fighters only. This checks each fighter's profile page, so if very few fighters match, the search stops after about 25 roster pages with no matches — narrow with a weight division for faster, fuller results.

## `country` (type: `string`):

Only include fighters from this country (e.g. "United States", "Brazil", "Russia"). Leave blank to include all countries. Applies to Fighters only. This checks each fighter's profile page, so for a country with few fighters the search stops after about 25 roster pages with no matches — combine with a weight division for faster, fuller results.

## `eventType` (type: `string`):

Whether to collect upcoming events, past events, or both. Applies to Events only.

## `includeDetails` (type: `boolean`):

Fetch the complete record for each result: striking and grappling career stats for fighters, or the full fight card with per-fight results for events. Turn this off for faster, cheaper runs that return only the listing-level summary. Has no effect on Rankings.

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

How many records to collect in total across all search terms. Default 100. You'll get at most this many — fewer when the source has fewer (Rankings always returns one row per division regardless of this value). Set to 0 to collect everything available, but note that 0 does not mean unlimited: every run also carries its own results limit, taken from the "Maximum results" or spend limit in the run's options, and whichever number is smaller wins. Unless you raise it, that limit typically stops an uncapped Fighters or Events sweep at a few hundred rows — the run then says exactly where it stopped and why. To collect more, raise the run's Maximum results (or its spend limit) before starting. Very large uncapped sweeps are also time-budgeted — Fighters roster runs (with or without full details) and Events calendar runs alike. If a run reaches the budget it stops and returns the records gathered so far (you'll see a note in the log) — set a specific number, or narrow with a weight division or event type, for a run that finishes cleanly.

## Actor input object example

```json
{
  "dataType": "fighters",
  "searchTerms": [
    "Jon Jones"
  ],
  "division": "",
  "gender": "",
  "fighterStatus": "",
  "eventType": "all",
  "includeDetails": true,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of extracted UFC records with key fields.

# 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 = {
    "dataType": "fighters",
    "searchTerms": [
        "Jon Jones"
    ],
    "division": "",
    "gender": "",
    "fighterStatus": "",
    "country": "",
    "eventType": "all",
    "includeDetails": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/ufc-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 = {
    "dataType": "fighters",
    "searchTerms": ["Jon Jones"],
    "division": "",
    "gender": "",
    "fighterStatus": "",
    "country": "",
    "eventType": "all",
    "includeDetails": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/ufc-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 '{
  "dataType": "fighters",
  "searchTerms": [
    "Jon Jones"
  ],
  "division": "",
  "gender": "",
  "fighterStatus": "",
  "country": "",
  "eventType": "all",
  "includeDetails": true,
  "maxResults": 100
}' |
apify call solidcode/ufc-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,solidcode/ufc-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/4lXiWKhbiTalTJzZb/builds/BI4mdDhfOEqXvJNK7/openapi.json