# Open5e SRD 5.1 Scraper (`parseforge/open5e-srd-scraper`) Actor

Export the System Reference Document 5.1 tabletop RPG dataset: 3,200+ monsters, 1,400+ spells, 1,600+ magic items, plus classes, races, weapons, armor, feats, conditions, and rules sections. Filter by challenge rating, spell level, search query, or resource type.

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

## Pricing

from $3.75 / 1,000 result items

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)

## 🐉 Open5e SRD 5.1 Scraper

> 🚀 **Export the SRD 5.1 tabletop RPG dataset in seconds.** Pull **3,200+ monsters, 1,400+ spells, 1,600+ magic items**, plus weapons, armor, classes, races, feats, backgrounds, conditions, and rules sections. No login, no API key, no manual JSON wrangling.

> 🕒 **Last updated:** 2026-05-21 · **📊 Up to 37 fields** per record · **🐉 3,207 monsters** · **🪄 1,435 spells** · **🗡️ 1,618 magic items**

The **Open5e SRD Scraper** exports the open-licensed System Reference Document 5.1 dataset and returns up to **37 fields per record**, including monster stat blocks, spell tables, magic item rarity, class progression, ability scores, saving throws, actions, legendary actions, and source attribution. The underlying dataset is curated by the Open5e community and includes content from the official SRD plus open-licensed expansions such as Tome of Beasts, Creature Codex, Vault of Magic, and Deep Magic.

Coverage spans **11 resource families**: 3,207 monsters, 1,435 spells, 1,618 magic items, 68 weapons, 23 armor sets, 12 classes, 20 races, 74 feats, 42 backgrounds, 15 conditions, and 45 rules sections. Records ship with license URLs so you stay compliant with the OGL and CC-BY terms of each contributing book.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| D&D tool builders, VTT (virtual tabletop) developers, game designers, RPG content creators, fan-site indexers, hobby DMs, encounter-balance app authors | Encounter builders, character sheet apps, spellbook UIs, monster lookups, rules wikis, game-design references, prompt seeds for AI dungeon masters |

---

### 📋 What the Open5e SRD Scraper does

Eleven resource families in a single Actor:

- 🐉 **Monsters.** Full stat blocks: HP, AC, six ability scores, saves, skills, senses, languages, damage modifiers, actions, legendary actions.
- 🪄 **Spells.** Level, school, casting time, range, components, duration, classes that can cast it, higher-level scaling.
- 🗡️ **Magic items.** Type, rarity, attunement requirement, description.
- ⚔️ **Weapons / Armor.** Damage dice, properties, AC formulas, stealth disadvantage, cost.
- 🧙 **Classes / Races.** Hit dice, proficiencies, ASIs, traits, subraces.
- 🎯 **Feats / Backgrounds / Conditions.** Prerequisites, effects, proficiencies, descriptions.
- 📜 **Rules sections.** Reference chapters indexed by slug.

Each record includes the source book title and license URL for redistribution compliance.

> 💡 **Why it matters:** building a 5e companion app means stitching together a dozen JSON schemas and license terms. Open5e already did the curation; this Actor turns the live dataset into one CSV/JSON pull that your build pipeline can refresh on every release.

---

### 🎬 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>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>
<tr><td><code>resourceType</code></td><td>string</td><td><code>"monsters"</code></td><td>One of 11 resource families.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>""</code></td><td>Free-text search inside the resource type.</td></tr>
<tr><td><code>challengeRating</code></td><td>string</td><td><code>""</code></td><td>Monsters only. Examples: <code>"0"</code>, <code>"1/4"</code>, <code>"5"</code>, <code>"20"</code>.</td></tr>
<tr><td><code>spellLevel</code></td><td>integer</td><td><code>null</code></td><td>Spells only. 0 for cantrips, 1-9 for leveled spells.</td></tr>
<tr><td><code>document</code></td><td>string</td><td><code>""</code></td><td>Restrict to one rules book (SRD, Tome of Beasts, Creature Codex, etc.).</td></tr>
</tbody>
</table>

**Example: every CR 5 monster from the SRD.**

```json
{
    "maxItems": 200,
    "resourceType": "monsters",
    "challengeRating": "5",
    "document": "wotc-srd"
}
````

**Example: 9th-level spells across every book.**

```json
{
    "maxItems": 50,
    "resourceType": "spells",
    "spellLevel": 9
}
```

> ⚠️ **Good to Know:** Open5e merges the official Wizards SRD with several open-licensed expansions. Each record's `sourceDocument` and `license` fields tell you which book a row came from so you can filter for redistribution-compliant subsets when shipping a public product.

***

### 📊 Output

Record shape varies by resource type. Monsters carry up to **37 fields**, spells around 20, magic items 10, and so on. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema (monsters)

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | null | Token art when available |
| 🐉 `resourceType` | string | `"monsters"` |
| 🆔 `slug` | string | `"a-mi-kuk"` |
| 🏷️ `name` | string | `"A-mi-kuk"` |
| ⚔️ `challengeRating` | string | `"7"` |
| 💗 `hitPoints` | number | `115` |
| 🛡️ `armorClass` | number | `14` |
| 📏 `size` | string | `"Huge"` |
| 🧬 `type` | string | `"Aberration"` |
| 🧭 `alignment` | string | `"chaotic evil"` |
| 🏃 `speed` | object | `{"walk": 30, "swim": 40, "burrow": 20}` |
| 💪 `abilityScores` | object | STR/DEX/CON/INT/WIS/CHA |
| 🛡️ `savingThrows` | object | Per-stat save bonuses |
| 🧠 `senses` | string | `"darkvision 60 ft., tremorsense 30 ft., passive Perception 15"` |
| 🗣️ `languages` | string | `"understands Common but can't speak"` |
| ⚡ `damageResistances` / `damageImmunities` / `damageVulnerabilities` | string | null | Damage type modifiers |
| 🚫 `conditionImmunities` | string | null | Status immunities |
| 🎯 `actions` / `legendaryActions` / `specialAbilities` | object\[] | null | Stat-block entries |
| 📜 `sourceDocument` | string | `"Tome of Beasts 2"` |
| 🔗 `sourceUrl` | string | Open5e page |
| 🕒 `scrapedAt` | ISO 8601 | Collection timestamp |

#### 📦 Sample records

<details>
<summary><strong>🐉 Huge aberration: A-mi-kuk (CR 7)</strong></summary>

```json
{
    "resourceType": "monsters",
    "slug": "a-mi-kuk",
    "name": "A-mi-kuk",
    "challengeRating": "7",
    "hitPoints": 115,
    "armorClass": 14,
    "size": "Huge",
    "type": "Aberration",
    "alignment": "chaotic evil",
    "speed": {"walk": 30, "swim": 40, "burrow": 20},
    "abilityScores": {"strength": 21, "dexterity": 8, "constitution": 20, "intelligence": 7, "wisdom": 14, "charisma": 10},
    "senses": "darkvision 60 ft., tremorsense 30 ft., passive Perception 15",
    "languages": "understands Common but can't speak",
    "sourceDocument": "Tome of Beasts 2",
    "sourceUrl": "https://open5e.com/monsters/a-mi-kuk"
}
```

</details>

<details>
<summary><strong>🐉 Huge aquatic monstrosity: Aalpamac (CR 7)</strong></summary>

```json
{
    "resourceType": "monsters",
    "slug": "aalpamac",
    "name": "Aalpamac",
    "challengeRating": "7",
    "hitPoints": 136,
    "armorClass": 16,
    "size": "Huge",
    "type": "Monstrosity",
    "alignment": "unaligned",
    "speed": {"walk": 15, "swim": 50},
    "abilityScores": {"strength": 21, "dexterity": 10, "constitution": 19, "intelligence": 2, "wisdom": 16, "charisma": 10},
    "senses": "darkvision 60 ft., passive Perception 16",
    "languages": "-",
    "sourceDocument": "Tome of Beasts 2",
    "sourceUrl": "https://open5e.com/monsters/aalpamac"
}
```

</details>

<details>
<summary><strong>🪄 Sample spell record (shape)</strong></summary>

```json
{
    "resourceType": "spells",
    "slug": "fireball",
    "name": "Fireball",
    "spellLevel": 3,
    "school": "Evocation",
    "castingTime": "1 action",
    "range": "150 feet",
    "components": "V, S, M",
    "duration": "Instantaneous",
    "concentration": false,
    "ritual": false,
    "classes": "Sorcerer, Wizard",
    "sourceUrl": "https://open5e.com/spells/fireball"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🐉 | **Eleven resource families.** One Actor returns monsters, spells, magic items, weapons, armor, classes, races, feats, backgrounds, conditions, and rules sections. |
| 📜 | **License-clean attribution.** Each record includes `sourceDocument` and `license` for OGL/CC-BY redistribution. |
| 🎯 | **Flexible filters.** Search query, challenge rating, spell level, and source document combine freely. |
| ⚡ | **Fast.** 10 monsters in under 5 seconds, 1,000 spells in under a minute. |
| 📊 | **Deep stat blocks.** Monsters expose six ability scores, saves, senses, actions, legendary actions, and special abilities. |
| 🔁 | **Always fresh.** Every run reflects the latest Open5e dataset, including new monster and spell pulls. |
| 🚫 | **No authentication.** Open SRD data. No login or token required. |

> 📊 The SRD 5.1 and its open-licensed expansions are the backbone of most independent 5e-compatible games and tools shipping today.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Open5e SRD Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **3,200 monsters · 1,400 spells · 1,600 items** | **Live per run** | type, query, CR, spell level, document | ⚡ 2 min |
| Manual page scraping | Free | Per-record | Manual | None | 🐢 Tedious |
| Bundled SRD JSON dumps | Free | Stale, SRD only | Rarely | None | 🕒 Variable |
| Commercial 5e content libraries | Subscription | Variable | Variable | Many | ⏳ Long signup |

Pick this Actor when you want the canonical open 5e dataset in CSV/JSON without writing a crawler or stitching multiple repos together.

***

### 🚀 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 Open5e SRD Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a resource type, optionally add a query, CR, spell level, or source document.
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">

#### 🧙 VTT and tabletop tools

- Bulk-import monsters into Foundry, Roll20, or custom VTTs
- Sync spellbooks with the latest open content releases
- Build encounter generators with CR-filtered queries
- Power character sheet apps with race/class/feat data

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

#### 📱 Companion apps

- Spell-lookup PWAs for players at the table
- Monster manuals for offline DM reference
- Magic-item generators tied to rarity tiers
- Random encounter generators by environment

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

#### 🎲 Game design and content

- Reference base monsters when designing third-party 5e content
- Compare class hit dice and proficiencies across editions
- Generate license-clean monster taxonomy for fan wikis
- Seed AI dungeon-master prompts with vetted stat blocks

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

#### 🛒 Marketplaces and aggregators

- Build searchable 5e content catalogs
- Score and rank content by completeness or popularity
- Aggregate cross-book lookups (SRD + Tome of Beasts + Creature Codex)
- Power 5e SaaS dashboards for DMs and publishers

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

***

### 🔌 Automating Open5e SRD 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 documentation](https://docs.apify.com/) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Weekly refreshes keep your VTT or app aligned with new Open5e content drops.

***

### 🌟 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

- Game-studies coursework with reproducible 5e content pulls
- Quantitative analysis of monster CR distribution or spell schools
- Computational linguistics on RPG corpus text
- Game-design teaching materials with worked examples

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

#### 🎨 Personal and creative

- Side projects: encounter generators, spell-card printers
- Custom DM screens and player handouts
- Personal homebrew databases that import the open base
- Hobby blogs and YouTube content with sourced stat blocks

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

#### 🤝 Non-profit and civic

- Accessibility-focused 5e companion apps for visually impaired players
- Open-source community wikis with proper attribution
- Free educational RPG kits for schools and libraries
- Translation projects to make 5e content multilingual

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

#### 🧪 Experimentation

- Train RPG-themed language models on clean stat blocks
- Prompt engineering for AI dungeon masters and NPC dialogue
- Agent pipelines that plan encounters and balance parties
- Hackathon projects for AI-powered tabletop tooling

</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%20Open5e%20SRD%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%20Open5e%20SRD%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%20Open5e%20SRD%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%20Open5e%20SRD%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

#### 🧩 How does it work?

Pick a resource type, optionally narrow by query, challenge rating, spell level, or source document, click Start, and the Actor walks the open Open5e dataset and emits one structured record per entry.

#### 📏 How accurate is the data?

Records mirror the live Open5e database. The community curators maintain parity with the published source books and patch known errata. For tournament play, validate against the official printed source.

#### 🔁 How often is the dataset refreshed?

Open5e ships updates as new open-licensed content arrives. Every run of this Actor pulls live, so your dataset reflects the latest curation.

#### 📜 What is the SRD?

The System Reference Document is the subset of 5e content released by Wizards of the Coast under the Open Gaming License (and later CC-BY). Open5e bundles the SRD with several other open-licensed books such as Tome of Beasts and Creature Codex.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (daily, weekly, monthly) and keep a downstream VTT or companion app in sync.

#### ⚖️ Is this data legal to use?

Yes within the OGL or CC-BY terms (depending on source book). The `license` field per record links to the relevant license text so you can stay compliant.

#### 💼 Can I use this data commercially?

Yes for open-licensed content. Read each record's license URL carefully; the OGL and CC-BY have different attribution rules.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling and higher concurrency.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. Partial datasets are preserved so you never lose progress.

#### 🎲 Can I get just the official SRD without expansions?

Yes. Set `document` to `wotc-srd` to restrict the run to the official Wizards SRD.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Open5e SRD 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 RPG 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. Refresh your VTT package or companion app database on each new dataset drop.

***

### 🔗 Recommended Actors

- [**🎨 Art Institute of Chicago Scraper**](https://apify.com/parseforge/art-institute-of-chicago-scraper) - 131k artworks from the AIC catalog
- [**📐 arXiv Preprint Scraper**](https://apify.com/parseforge/arxiv-scraper) - Open-access research papers
- [**📝 Datamuse Word Finder Scraper**](https://apify.com/parseforge/datamuse-words-scraper) - English word relations and dictionaries
- [**📊 OurAirports Global Airport Database Scraper**](https://apify.com/parseforge/ourairports-scraper) - Worldwide airport reference data

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more 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.

***

# Actor input Schema

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

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

## `resourceType` (type: `string`):

Which SRD resource family to scrape.

## `searchQuery` (type: `string`):

Free-text search across the chosen resource. Examples: 'dragon', 'fireball', 'cloak'.

## `challengeRating` (type: `string`):

Monsters only. Filter monsters by their challenge rating.

## `spellLevel` (type: `integer`):

Spells only. 0 for cantrips, 1-9 for leveled spells.

## `document` (type: `string`):

Restrict to one rules document.

## Actor input object example

```json
{
  "maxItems": 10,
  "resourceType": "monsters"
}
```

# Actor output Schema

## `overview` (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,
    "resourceType": "monsters",
    "document": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/open5e-srd-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,
    "resourceType": "monsters",
    "document": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/open5e-srd-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,
  "resourceType": "monsters",
  "document": ""
}' |
apify call parseforge/open5e-srd-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open5e SRD 5.1 Scraper",
        "description": "Export the System Reference Document 5.1 tabletop RPG dataset: 3,200+ monsters, 1,400+ spells, 1,600+ magic items, plus classes, races, weapons, armor, feats, conditions, and rules sections. Filter by challenge rating, spell level, search query, or resource type.",
        "version": "1.0",
        "x-build-id": "VQ5nCWfCiD4LAgfU1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~open5e-srd-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-open5e-srd-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~open5e-srd-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-open5e-srd-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~open5e-srd-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-open5e-srd-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"
                    },
                    "resourceType": {
                        "title": "Resource Type",
                        "enum": [
                            "monsters",
                            "spells",
                            "magicitems",
                            "weapons",
                            "armor",
                            "classes",
                            "races",
                            "feats",
                            "backgrounds",
                            "conditions",
                            "sections"
                        ],
                        "type": "string",
                        "description": "Which SRD resource family to scrape."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text search across the chosen resource. Examples: 'dragon', 'fireball', 'cloak'."
                    },
                    "challengeRating": {
                        "title": "Challenge Rating (monsters)",
                        "enum": [
                            "",
                            "0",
                            "1/8",
                            "1/4",
                            "1/2",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6",
                            "7",
                            "8",
                            "9",
                            "10",
                            "11",
                            "12",
                            "13",
                            "14",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "20",
                            "21",
                            "22",
                            "23",
                            "24",
                            "25",
                            "26",
                            "27",
                            "28",
                            "29",
                            "30"
                        ],
                        "type": "string",
                        "description": "Monsters only. Filter monsters by their challenge rating."
                    },
                    "spellLevel": {
                        "title": "Spell Level (spells)",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Spells only. 0 for cantrips, 1-9 for leveled spells."
                    },
                    "document": {
                        "title": "Source Document",
                        "enum": [
                            "",
                            "wotc-srd",
                            "tob",
                            "tob2",
                            "menagerie",
                            "cc",
                            "a5e",
                            "kp",
                            "o5e",
                            "tob3",
                            "vom",
                            "dmag",
                            "dmag-e",
                            "warlock"
                        ],
                        "type": "string",
                        "description": "Restrict to one rules document."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
