# D\&D 5e SRD Content Scraper (`parseforge/dnd5e-srd-spells-scraper`) Actor

Export D\&D 5e SRD (System Reference Document) content from the canonical dnd5eapi.co source. Pull spells, monsters, classes, equipment, magic items, and features with full rules text, level, school, damage, components, and class associations.

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

## Pricing

from $9.00 / 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)

## 🐉 D&D 5e SRD Content Scraper

> 🚀 **Export the official D&D 5th Edition System Reference Document in seconds.** Pull **319+ spells, 334+ monsters, classes, equipment, magic items, races, backgrounds, conditions, and 18 more resource types** from the canonical dnd5eapi.co source. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-22 · **📊 Up to 54 fields** per record · **🐉 24 resource types** · **🪄 319+ spells** · **👹 334+ monsters** · **⚔️ 237+ equipment**

The **D&D 5e SRD Content Scraper** exports the canonical SRD (System Reference Document) corpus from dnd5eapi.co, the open-license reference implementation of the Wizards of the Coast SRD 5.1. It returns up to **54 fields per record**, including full rules text, level, school, damage, components, class associations, monster stat blocks, equipment costs, and magic-item rarities. dnd5eapi.co is the most widely cited open D&D API and powers character builders, virtual tabletops, and AI dungeon-master tools across the TTRPG community.

The catalog covers **24 SRD resource types** spanning spells, monsters, classes, subclasses, races, subraces, backgrounds, features, traits, feats, equipment, magic items, weapons, conditions, damage types, magic schools, alignments, languages, skills, ability scores, proficiencies, rules and rule sections. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in under five minutes. All filters run server-side, so you skip the parser engineering entirely.

> 🧭 **Source clarity:** this scraper pulls from **dnd5eapi.co**, the canonical D&D SRD reference. For the community-extended Open5e dataset (which includes Pathfinder, third-party content, and homebrew), use our companion `open5e-srd-scraper` instead.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| TTRPG tool builders, virtual tabletop developers, D&D content sites, character-builder apps, AI dungeon masters, encounter generators, fan-wiki maintainers | Spell autocomplete, monster stat-block databases, encounter-builder feeds, character-sheet engines, AI DM grounding, search and filtering UX |

---

### 📋 What the D&D 5e SRD Content Scraper does

Two filtering workflows in a single run:

- 📚 **Resource-type filter.** Pick one of 24 SRD resource types: spells, monsters, classes, equipment, magic items, features, ability scores, alignments, backgrounds, conditions, damage types, equipment categories, feats, languages, magic schools, proficiencies, races, rule sections, rules, skills, subclasses, subraces, traits, weapon properties.
- 🔍 **Name filter.** Case-insensitive substring match (e.g. `fireball`, `dragon`, `paladin`).

Each record returns the appropriate fields for the resource type. Spells include level, school, damage table, components, range, duration, casting time, ritual flag, and class lists. Monsters include AC, HP, hit dice, speed, ability scores, proficiencies, vulnerabilities/resistances/immunities, senses, languages, special abilities, and full action/legendary-action blocks with attack bonuses and damage rolls. Equipment includes cost, weight, weapon category and properties. Magic items include rarity and full effect text.

> 💡 **Why it matters:** the SRD is the legal open-license baseline for fifth-edition D&D content. Every Roll20 character sheet, Foundry VTT module, AI dungeon master, and community wiki ultimately resolves back to it. Building your own parser means crawling 24 endpoints and normalizing wildly different shapes. This Actor flattens all of that into a unified dataset.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded SRD 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>"spells"</code></td><td>One of 24 SRD resource types.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>""</code></td><td>Case-insensitive substring match on resource name. Empty = all.</td></tr>
</tbody>
</table>

**Example: every spell with "fire" in the name.**

```json
{
    "maxItems": 50,
    "resourceType": "spells",
    "searchQuery": "fire"
}
````

**Example: every dragon stat block.**

```json
{
    "maxItems": 30,
    "resourceType": "monsters",
    "searchQuery": "dragon"
}
```

> ⚠️ **Good to Know:** different resource types return different field sets. Spells populate `level`, `school`, `damageType`, and `classes`; monsters populate `armorClass`, `hitPoints`, `speed`, and `actions`. Fields not relevant to the resource type are simply omitted from the output.

***

### 📊 Output

Each record contains up to **54 fields** depending on resource type. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema (key fields)

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | null | `"https://www.dnd5eapi.co/api/images/monsters/adult-red-dragon.png"` |
| 🏷️ `name` | string | `"Fireball"` |
| 🔖 `index` | string | `"fireball"` |
| 📚 `resourceType` | string | `"spells"` |
| 🎚️ `level` | number | `3` |
| 🔮 `school` | string | `"Evocation"` |
| 🔥 `damageType` | string | `"Fire"` |
| 📊 `damageAtSlotLevel` | object | `{"3": "8d6", "4": "9d6"}` |
| 🎯 `areaOfEffect` | object | `{"type": "sphere", "size": 20}` |
| 🛡️ `dc` | object | `{"dc_type": "DEX", "dc_success": "half"}` |
| 📏 `range` | string | `"150 feet"` |
| 🧪 `components` | array | `["V", "S", "M"]` |
| 🧫 `material` | string | `"A tiny ball of bat guano and sulfur"` |
| ⏱️ `castingTime` | string | `"1 action"` |
| 🪄 `duration` | string | `"Instantaneous"` |
| 🎓 `classes` | array | `["Sorcerer", "Wizard"]` |
| 📝 `description` | string | `"A bright streak flashes from your pointing finger..."` |
| 👹 `monsterType` | string | `"dragon"` |
| 🐲 `size` | string | `"Huge"` |
| ⚖️ `alignment` | string | `"chaotic evil"` |
| 💀 `challengeRating` | number | `17` |
| ❤️ `hitPoints` | number | `256` |
| 🎲 `hitDice` | string | `"19d12"` |
| 💨 `speed` | object | `{"walk": "40 ft.", "fly": "80 ft."}` |
| 💪 `abilityScores` | object | `{"strength": 27, "dexterity": 10, ...}` |
| ⚔️ `actions` | array | full action blocks |
| 👑 `legendaryActions` | array | legendary action blocks |
| 💰 `cost` | object | `{"quantity": 50, "unit": "gp"}` |
| ⚖️ `weight` | number | `6` |
| 💎 `rarity` | string | `"very rare"` |
| 🔗 `detailUrl` | string | `"https://www.dnd5eapi.co/api/spells/fireball"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🪄 Iconic spell: Fireball</strong></summary>

```json
{
    "name": "Fireball",
    "index": "fireball",
    "resourceType": "spells",
    "level": 3,
    "school": "Evocation",
    "damageType": "Fire",
    "damageAtSlotLevel": {"3": "8d6", "4": "9d6", "5": "10d6"},
    "areaOfEffect": {"type": "sphere", "size": 20},
    "dc": {"dc_type": "DEX", "dc_success": "half"},
    "range": "150 feet",
    "components": ["V", "S", "M"],
    "material": "A tiny ball of bat guano and sulfur",
    "ritual": false,
    "concentration": false,
    "duration": "Instantaneous",
    "castingTime": "1 action",
    "classes": ["Sorcerer", "Wizard"],
    "subclasses": ["Lore"],
    "description": "A bright streak flashes from your pointing finger to a point you choose within range and then blossoms with a low roar into an explosion of flame.",
    "higherLevel": "When you cast this spell using a spell slot of 4th level or higher, the damage increases by 1d6 for each slot level above 3rd.",
    "detailUrl": "https://www.dnd5eapi.co/api/spells/fireball",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>👹 Boss monster: Adult Red Dragon</strong></summary>

```json
{
    "imageUrl": "https://www.dnd5eapi.co/api/images/monsters/adult-red-dragon.png",
    "name": "Adult Red Dragon",
    "index": "adult-red-dragon",
    "resourceType": "monsters",
    "monsterType": "dragon",
    "size": "Huge",
    "alignment": "chaotic evil",
    "challengeRating": 17,
    "xp": 18000,
    "armorClass": [{"type": "natural", "value": 19}],
    "hitPoints": 256,
    "hitDice": "19d12",
    "speed": {"walk": "40 ft.", "climb": "40 ft.", "fly": "80 ft."},
    "abilityScores": {"strength": 27, "dexterity": 10, "constitution": 25, "intelligence": 16, "wisdom": 13, "charisma": 21},
    "damageImmunities": ["fire"],
    "senses": {"blindsight": "60 ft.", "darkvision": "120 ft.", "passive_perception": 23},
    "languages": "Common, Draconic",
    "actions": [
        {"name": "Bite", "attack_bonus": 14, "damage": "2d10 + 8 piercing plus 4d6 fire"},
        {"name": "Fire Breath", "usage": "Recharge 5-6", "damage": "18d6 fire"}
    ],
    "legendaryActions": [
        {"name": "Detect"},
        {"name": "Tail Attack"},
        {"name": "Wing Attack (Costs 2 Actions)"}
    ],
    "detailUrl": "https://www.dnd5eapi.co/api/monsters/adult-red-dragon",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>⚔️ Magic item: Vorpal Sword</strong></summary>

```json
{
    "name": "Vorpal Sword",
    "index": "vorpal-sword",
    "resourceType": "magic-items",
    "equipmentCategory": "Weapon",
    "rarity": "legendary",
    "description": "You gain a +3 bonus to attack and damage rolls made with this magic weapon. In addition, the weapon ignores resistance to slashing damage. When you attack a creature that has at least one head with this weapon and roll a 20 on the attack roll, you cut off one of the creature's heads.",
    "detailUrl": "https://www.dnd5eapi.co/api/magic-items/vorpal-sword",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🐉 | **Canonical SRD source.** Built on dnd5eapi.co, the most widely cited open D\&D reference. |
| 📚 | **24 resource types.** Spells, monsters, classes, equipment, magic items, races, and 18 more, all in one Actor. |
| 🔮 | **Rich structured data.** Full damage tables, components, monster stat blocks, legendary actions, and class lists. |
| 🔍 | **Substring search.** No need to know exact slugs (`fireball` finds Fireball, Fire Bolt, etc.). |
| ⚡ | **Fast.** 10 records in under 5 seconds, the full catalog in under a minute. |
| ⚖️ | **Open license.** OGL-licensed SRD content, commercial use permitted with attribution. |
| 🚫 | **No authentication.** Works with the public dnd5eapi.co source. No login needed. |

> 📊 Clean, structured SRD data is the foundation of every D\&D character builder, virtual tabletop, AI dungeon master, and encounter generator on the market.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ D\&D 5e SRD Content Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **24 resource types, 1,800+ records** | **Live per run** | type, name | ⚡ 2 min |
| Hand-curating SRD JSON | Free | Whatever you write | Manual | None | 🐌 Weeks |
| Crawling the dnd5eapi yourself | Free | Full | Live | Build your own | 🕒 Days of engineering |
| Commercial TTRPG content APIs | $50+/month | Often subset, license-gated | Vendor-controlled | Varies | 🐢 Days |

Pick this Actor when you want the entire SRD flattened into a clean dataset with zero parser maintenance.

***

### 🚀 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 D\&D 5e SRD Content Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a resource type, optionally filter by name substring, set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

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

***

### 💼 Business use cases

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

#### 🎲 Character Builders & Sheet Apps

- Spell autocomplete and search
- Class, race, and background pickers
- Feature and trait lookup tables
- Level-up rule resolution

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

#### 🗺️ Virtual Tabletops (VTT)

- Pre-loaded monster stat blocks
- Spell card generation for player handouts
- Encounter-builder weighting by CR
- Item compendiums with rarity sorting

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

#### 🤖 AI Dungeon Masters & Bots

- Grounded retrieval source for AI DMs
- Rules-clarification responses with citations
- Random-encounter generation with valid CR
- NPC stat-block lookups during play

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

#### 📚 Fan Wikis & Content Sites

- Searchable spell, monster, and item databases
- Class progression pages with auto-generated tables
- Cross-reference indexes (spells by class, items by rarity)
- SEO-friendly category listings

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

***

### 🔌 Automating D\&D 5e SRD Content Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

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

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. The SRD itself rarely changes, so a weekly or monthly schedule is plenty.

***

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

- Tabletop RPG game-design studies
- Computational analyses of monster balance and CR
- Reproducible studies with cited dataset pulls
- Open game-design coursework

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

#### 🎨 Personal and creative

- Side projects, indie character builders, hobby tools
- Personal campaign trackers for home games
- D\&D content for YouTube and Twitch streamers
- Hobbyist worldbuilding databases

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

#### 🤝 Non-profit and civic

- Library and community-center RPG programs
- Open educational TTRPG resources for classrooms
- Therapy and education-through-play initiatives
- Game-design clubs at schools and universities

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

#### 🧪 Experimentation

- Train spell-effect or encounter-balance ML models
- Validate VTT product hypotheses with real data
- Prototype LLM agents that play or run D\&D
- Test embedding strategies on rules text

</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%20D%26D%205e%20SRD%20Content%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%20D%26D%205e%20SRD%20Content%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%20D%26D%205e%20SRD%20Content%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%20D%26D%205e%20SRD%20Content%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 and optional name substring in the input form, click Start, and the Actor fetches the matching SRD records from the canonical dnd5eapi.co source and emits a clean structured record per item. No browser automation, no captchas, no setup.

#### 📚 What is the SRD?

The System Reference Document is the open-license subset of D\&D 5th Edition that Wizards of the Coast publishes under the OGL (Open Game License) and Creative Commons. It is the legal foundation that lets third-party tools, character builders, and VTTs interoperate with D\&D content.

#### 🆚 How is this different from your Open5e scraper?

This Actor pulls from **dnd5eapi.co**, the canonical SRD source. Our companion `open5e-srd-scraper` pulls from Open5e, which is a community-extended dataset that also includes Pathfinder content and third-party homebrew. Use this Actor when you want canonical SRD only; use the Open5e one when you want the expanded universe.

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

The SRD itself rarely changes (major revisions every few years). dnd5eapi.co is updated incrementally; every run of this Actor fetches the latest data.

#### 🐲 Does it include high-level content like CR 20+ monsters?

Yes. The full SRD monster list (CR 0 through CR 30) is included. Use `searchQuery: "ancient"` to find ancient dragons, for example.

#### ⏰ Can I schedule regular runs?

Yes. A weekly or monthly Apify Schedule is more than enough since SRD content is stable.

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

Yes. The SRD is published under the OGL 1.0a and Creative Commons. Commercial use is permitted with proper attribution. Always review the current SRD license terms for the specific use case.

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

Yes, with attribution per the SRD license. Most major D\&D-adjacent products (character builders, VTTs, third-party adventures) operate under this license.

#### 💳 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, higher concurrency, and larger datasets.

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

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

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

D\&D 5e SRD Content 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 SRD 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. Push fresh SRD data into your VTT, character-builder, or AI DM backend.

***

### 🔗 Recommended Actors

- [**🐉 Open5e SRD Scraper**](https://apify.com/parseforge/open5e-srd-scraper) - Community-extended TTRPG content
- [**🎮 Valorant Game Content Scraper**](https://apify.com/parseforge/valorant-game-content-scraper) - Valorant agents, maps, weapons
- [**📚 Open Library Scraper**](https://apify.com/parseforge/open-library-scraper) - Book metadata and author records
- [**🌐 Wikipedia Article Scraper**](https://apify.com/parseforge/wikipedia-article-scraper) - Structured encyclopedia content
- [**🎓 OpenStax Textbook Scraper**](https://apify.com/parseforge/openstax-scraper) - Open-license academic content

> 💡 **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.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Wizards of the Coast LLC, dnd5eapi.co, or any official D\&D publisher. Dungeons & Dragons and D\&D are trademarks of Wizards of the Coast. All trademarks mentioned are the property of their respective owners. Only publicly available SRD content released under the OGL and Creative Commons is collected.

# 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 to export.

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

Case-insensitive substring match against the resource name (e.g. 'fireball', 'dragon'). Leave blank for all.

## Actor input object example

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

# 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": "spells"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "D&D 5e SRD Content Scraper",
        "description": "Export D&D 5e SRD (System Reference Document) content from the canonical dnd5eapi.co source. Pull spells, monsters, classes, equipment, magic items, and features with full rules text, level, school, damage, components, and class associations.",
        "version": "1.0",
        "x-build-id": "WaD5IMSsbtlVTEtwt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~dnd5e-srd-spells-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-dnd5e-srd-spells-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~dnd5e-srd-spells-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-dnd5e-srd-spells-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~dnd5e-srd-spells-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-dnd5e-srd-spells-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": [
                            "spells",
                            "monsters",
                            "classes",
                            "equipment",
                            "magic-items",
                            "features",
                            "ability-scores",
                            "alignments",
                            "backgrounds",
                            "conditions",
                            "damage-types",
                            "equipment-categories",
                            "feats",
                            "languages",
                            "magic-schools",
                            "proficiencies",
                            "races",
                            "rule-sections",
                            "rules",
                            "skills",
                            "subclasses",
                            "subraces",
                            "traits",
                            "weapon-properties"
                        ],
                        "type": "string",
                        "description": "Which SRD resource to export."
                    },
                    "searchQuery": {
                        "title": "Name Filter",
                        "type": "string",
                        "description": "Case-insensitive substring match against the resource name (e.g. 'fireball', 'dragon'). Leave blank for all."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
