# Open5e D\&D 5e SRD Scraper (`crawlerbros/open5e-dnd-scraper`) Actor

Scrape the Open5e API - Dungeons & Dragons 5e SRD content. Fetch monsters, spells, magic items, races, classes, weapons and armor with full stats, descriptions and sourcebook attribution.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Open5e D&D 5e SRD Scraper

Pull structured **Dungeons & Dragons 5th Edition** content straight from the open **[Open5e](https://open5e.com/) API** — monsters, spells, magic items, races, classes, weapons and armor — as clean, ready-to-use JSON. No account, no API key, no login.

Perfect for building character-builder tools, encounter generators, homebrew databases, Discord bots, spreadsheets, or any app that needs reliable 5e SRD reference data.

### What this actor does

- Searches and browses seven categories of 5e content.
- Returns full stat blocks and descriptions with **sourcebook attribution** so you always know where each entry comes from.
- Lets you filter monsters by type / size / challenge rating, spells by level / school / class, and magic items by rarity / attunement.
- Fetches specific entries directly by their Open5e slug.
- Empty fields are always omitted — you never get `null`s.

### Content types

| Content type | Records available | Example fields |
|---|---|---|
| **Monsters** | 3,200+ | full stat block, actions, abilities, challenge rating |
| **Spells** | 1,400+ | level, school, casting time, range, components |
| **Magic items** | 1,600+ | type, rarity, attunement, description |
| **Races** | 20+ | ability score increase, traits, subraces, speed |
| **Classes** | 12 | hit dice, proficiencies, spellcasting, archetypes |
| **Weapons** | 68 | damage dice, damage type, cost, properties |
| **Armor** | 23 | base AC, cost, strength requirement, stealth |

### Output

Every record includes `recordType`, `slug`, `name`, `sourceUrl` (the live Open5e API URL for that entry), `documentTitle` (the sourcebook it comes from), `licenseUrl` (the licence page for that content), and `scrapedAt` (UTC timestamp). Additional fields depend on the content type.

**Monsters:** `size`, `type`, `subtype`, `alignment`, `challengeRating`, `crValue`, `armorClass`, `armorDesc`, `hitPoints`, `hitDice`, `speed`, `strength`, `dexterity`, `constitution`, `intelligence`, `wisdom`, `charisma`, `skills`, `savingThrows`, `senses`, `languages`, `damageVulnerabilities`, `damageResistances`, `damageImmunities`, `conditionImmunities`, `description`, `actions`, `bonusActions`, `reactions`, `specialAbilities`, `legendaryActions`, `legendaryDescription`, `environments`, `imageUrl`.

**Spells:** `school`, `level`, `levelText`, `castingTime`, `range`, `duration`, `components`, `requiresVerbalComponents`, `requiresSomaticComponents`, `requiresMaterialComponents`, `material`, `requiresConcentration`, `ritual`, `description`, `higherLevel`, `dndClasses`, `spellLists`.

**Magic items:** `type`, `rarity`, `requiresAttunement`, `description`.

**Races:** `description`, `abilityScoreIncrease`, `abilityScoreIncreases`, `age`, `alignment`, `size`, `speed`, `speedDesc`, `languages`, `vision`, `traits`, `subraces`.

**Classes:** `description`, `hitDice`, `hpAtFirstLevel`, `hpAtHigherLevels`, `proficiencyArmor`, `proficiencyWeapons`, `proficiencyTools`, `proficiencySavingThrows`, `proficiencySkills`, `spellcastingAbility`, `startingEquipment`, `archetypeGroupName`, `progressionTable`, `archetypes`.

**Weapons:** `category`, `cost`, `damageDice`, `damageType`, `weight`, `properties`.

**Armor:** `category`, `acString`, `baseAc`, `cost`, `weight`, `strengthRequirement`, `plusDexMod`, `plusMaxDexBonus`, `stealthDisadvantage`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `contentType` | select | `monsters` | Which category to fetch: monsters, spells, magicItems, races, classes, weapons, armor. |
| `search` | string | `dragon` | Free-text search across names and descriptions (e.g. `dragon`, `fireball`). Leave empty to browse the whole category. |
| `slugs` | array | – | Fetch specific entries by Open5e slug (e.g. `adult-red-dragon`, `fireball`). When set, other filters are ignored. |
| `monsterType` | select | – | Monsters only — filter by creature type (Dragon, Undead, Swarm, …). |
| `size` | select | – | Monsters only — filter by size (Tiny … Gargantuan). |
| `crMin` / `crMax` | integer | – | Monsters only — challenge-rating range (0–30). |
| `spellLevel` | integer | – | Spells only — spell level (0 = cantrip … 9). |
| `school` | select | – | Spells only — school of magic (Evocation, Necromancy, …). |
| `dndClass` | select | – | Spells only — class that can cast the spell. |
| `concentration` | boolean | `false` | Spells only — when enabled, only spells that require concentration. |
| `spellRitual` | boolean | `false` | Spells only — when enabled, only spells that can be cast as a ritual. |
| `rarity` | select | – | Magic items only — rarity (Common … Artifact). |
| `requiresAttunement` | boolean | `false` | Magic items only — only items requiring attunement. |
| `maxItems` | integer | `25` | Hard cap on emitted records (1–5000). |

#### Example: high-CR dragons

```json
{
  "contentType": "monsters",
  "monsterType": "Dragon",
  "crMin": 10,
  "crMax": 20,
  "maxItems": 25
}
````

#### Example: 3rd-level evocation spells

```json
{
  "contentType": "spells",
  "spellLevel": 3,
  "school": "Evocation",
  "maxItems": 50
}
```

#### Example: legendary magic items requiring attunement

```json
{
  "contentType": "magicItems",
  "rarity": "Legendary",
  "requiresAttunement": true,
  "maxItems": 50
}
```

#### Example: lookup specific entries by slug

```json
{
  "contentType": "monsters",
  "slugs": ["adult-red-dragon", "aboleth", "lich"]
}
```

#### Example output (monster)

```json
{
  "recordType": "monster",
  "slug": "adult-red-dragon",
  "name": "Adult Red Dragon",
  "size": "Huge",
  "type": "Dragon",
  "challengeRating": "17",
  "crValue": 17.0,
  "armorClass": 19,
  "hitPoints": 256,
  "speed": { "walk": 40, "fly": 80, "climb": 40 },
  "actions": [{ "name": "Bite", "desc": "Melee Weapon Attack: +14 to hit…" }],
  "documentTitle": "5e Core Rules",
  "sourceUrl": "https://api.open5e.com/v1/monsters/adult-red-dragon/",
  "scrapedAt": "2026-07-02T13:23:35.202585+00:00"
}
```

### Use cases

- **VTT & app developers** — bulk-import a complete 5e bestiary or spell list into your virtual tabletop or character builder.
- **Encounter design** — pull all monsters in a challenge-rating band to balance an encounter.
- **Discord bots** — look up any monster, spell, or item on demand by slug.
- **Homebrew databases** — seed a reference database with SRD and openly licensed third-party content.
- **Data analysis** — export spell distributions by school/level or item rarity for game-balance studies.
- **Spreadsheets** — feed clean JSON into no-code tools for DM prep sheets.

### FAQ

**Do I need an API key or account?**
No. Open5e is a fully open, public API. The actor works out of the box.

**Where does the data come from?**
The [Open5e](https://open5e.com/) project, which aggregates the D\&D 5e System Reference Document (SRD) plus a range of openly licensed third-party sourcebooks. Each record carries a `documentTitle` telling you which book it belongs to.

**Why do some entries look different?**
Different sourcebooks publish slightly different fields. The actor only outputs fields that are actually present, so records stay clean and never contain empty values.

**Can I get a specific monster or spell?**
Yes — put its slug(s) in the `slugs` field and set the matching `contentType`. Duplicate slugs are automatically de-duplicated.

**How do I get everything in a category?**
Leave `search` empty and raise `maxItems`.

**Are the filters case-sensitive?**
No. Open5e stores some categories in mixed case (e.g. both `Evocation` and `evocation`); the actor matches them case-insensitively so a single filter value catches every variant.

### Data source

This actor uses the public Open5e REST API at `https://api.open5e.com`. Content is provided under the Open Gaming License / Creative Commons licenses referenced by each sourcebook.

# Actor input Schema

## `contentType` (type: `string`):

Which category of 5e content to fetch.

## `search` (type: `string`):

Free-text search across names and descriptions (e.g. `dragon`, `fireball`). Leave empty to browse the whole category.

## `slugs` (type: `array`):

Fetch specific entries by Open5e slug (e.g. `adult-red-dragon`, `fireball`). When set, other filters are ignored and each slug is fetched from the selected content type.

## `monsterType` (type: `string`):

Filter monsters by creature type.

## `size` (type: `string`):

Filter monsters by size.

## `crMin` (type: `integer`):

Only include monsters with challenge rating >= this value.

## `crMax` (type: `integer`):

Only include monsters with challenge rating <= this value.

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

Filter spells by level (0 = cantrip, up to 9).

## `school` (type: `string`):

Filter spells by school of magic.

## `dndClass` (type: `string`):

Filter spells available to a class.

## `concentration` (type: `boolean`):

When enabled, only include spells that require concentration.

## `spellRitual` (type: `boolean`):

When enabled, only include spells that can be cast as a ritual.

## `rarity` (type: `string`):

Filter magic items by rarity.

## `requiresAttunement` (type: `boolean`):

When enabled, only include magic items that require attunement.

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

Hard cap on emitted records. The scraper paginates until it reaches this many records or the category is exhausted.

## Actor input object example

```json
{
  "contentType": "monsters",
  "search": "dragon",
  "slugs": [],
  "monsterType": "",
  "size": "",
  "school": "",
  "dndClass": "",
  "concentration": false,
  "spellRitual": false,
  "rarity": "",
  "requiresAttunement": false,
  "maxItems": 25
}
```

# Actor output Schema

## `content` (type: `string`):

Dataset containing all scraped Open5e records.

# 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 = {
    "contentType": "monsters",
    "search": "dragon",
    "slugs": [],
    "requiresAttunement": false,
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/open5e-dnd-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 = {
    "contentType": "monsters",
    "search": "dragon",
    "slugs": [],
    "requiresAttunement": False,
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/open5e-dnd-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 '{
  "contentType": "monsters",
  "search": "dragon",
  "slugs": [],
  "requiresAttunement": false,
  "maxItems": 25
}' |
apify call crawlerbros/open5e-dnd-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open5e D&D 5e SRD Scraper",
        "description": "Scrape the Open5e API - Dungeons & Dragons 5e SRD content. Fetch monsters, spells, magic items, races, classes, weapons and armor with full stats, descriptions and sourcebook attribution.",
        "version": "1.0",
        "x-build-id": "w7sdSlOYpRXXfOsqa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~open5e-dnd-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-open5e-dnd-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/crawlerbros~open5e-dnd-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-open5e-dnd-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/crawlerbros~open5e-dnd-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-open5e-dnd-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",
                "required": [
                    "contentType"
                ],
                "properties": {
                    "contentType": {
                        "title": "Content type",
                        "enum": [
                            "monsters",
                            "spells",
                            "magicItems",
                            "races",
                            "classes",
                            "weapons",
                            "armor"
                        ],
                        "type": "string",
                        "description": "Which category of 5e content to fetch.",
                        "default": "monsters"
                    },
                    "search": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search across names and descriptions (e.g. `dragon`, `fireball`). Leave empty to browse the whole category.",
                        "default": "dragon"
                    },
                    "slugs": {
                        "title": "Slugs (direct lookup)",
                        "type": "array",
                        "description": "Fetch specific entries by Open5e slug (e.g. `adult-red-dragon`, `fireball`). When set, other filters are ignored and each slug is fetched from the selected content type.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "monsterType": {
                        "title": "Monster type (monsters)",
                        "enum": [
                            "",
                            "Aberration",
                            "Beast",
                            "Celestial",
                            "Construct",
                            "Dragon",
                            "Elemental",
                            "Fey",
                            "Fiend",
                            "Giant",
                            "Humanoid",
                            "Monstrosity",
                            "Ooze",
                            "Plant",
                            "Swarm",
                            "Undead"
                        ],
                        "type": "string",
                        "description": "Filter monsters by creature type.",
                        "default": ""
                    },
                    "size": {
                        "title": "Creature size (monsters)",
                        "enum": [
                            "",
                            "Tiny",
                            "Small",
                            "Medium",
                            "Large",
                            "Huge",
                            "Gargantuan"
                        ],
                        "type": "string",
                        "description": "Filter monsters by size.",
                        "default": ""
                    },
                    "crMin": {
                        "title": "Min challenge rating (monsters)",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Only include monsters with challenge rating >= this value."
                    },
                    "crMax": {
                        "title": "Max challenge rating (monsters)",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Only include monsters with challenge rating <= this value."
                    },
                    "spellLevel": {
                        "title": "Spell level (spells)",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Filter spells by level (0 = cantrip, up to 9)."
                    },
                    "school": {
                        "title": "Spell school (spells)",
                        "enum": [
                            "",
                            "Abjuration",
                            "Conjuration",
                            "Divination",
                            "Enchantment",
                            "Evocation",
                            "Illusion",
                            "Necromancy",
                            "Transmutation"
                        ],
                        "type": "string",
                        "description": "Filter spells by school of magic.",
                        "default": ""
                    },
                    "dndClass": {
                        "title": "Spellcasting class (spells)",
                        "enum": [
                            "",
                            "Bard",
                            "Cleric",
                            "Druid",
                            "Paladin",
                            "Ranger",
                            "Sorcerer",
                            "Warlock",
                            "Wizard",
                            "Artificer"
                        ],
                        "type": "string",
                        "description": "Filter spells available to a class.",
                        "default": ""
                    },
                    "concentration": {
                        "title": "Requires concentration (spells)",
                        "type": "boolean",
                        "description": "When enabled, only include spells that require concentration.",
                        "default": false
                    },
                    "spellRitual": {
                        "title": "Ritual spells only (spells)",
                        "type": "boolean",
                        "description": "When enabled, only include spells that can be cast as a ritual.",
                        "default": false
                    },
                    "rarity": {
                        "title": "Rarity (magic items)",
                        "enum": [
                            "",
                            "Common",
                            "Uncommon",
                            "Rare",
                            "Very Rare",
                            "Legendary",
                            "Artifact"
                        ],
                        "type": "string",
                        "description": "Filter magic items by rarity.",
                        "default": ""
                    },
                    "requiresAttunement": {
                        "title": "Requires attunement (magic items)",
                        "type": "boolean",
                        "description": "When enabled, only include magic items that require attunement.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on emitted records. The scraper paginates until it reaches this many records or the category is exhausted.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```