# AnimeThemes Anime Songs Scraper (`parseforge/animethemes-anime-songs-scraper`) Actor

Pull anime opening and ending themes from AnimeThemes.moe with anime name, season, year, theme type like OP or ED, song title, performing artists, and direct audio and video links. Filter by name, season, or year. Useful for building playlists, music research, and anime databases.

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

## Pricing

from $7.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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)

## 🎵 AnimeThemes Anime Songs Scraper

> 🚀 **Export anime opening and ending themes in one run.** Pull OPs and EDs from AnimeThemes.moe with song titles, artists, and direct audio and video links.

> 🕒 **Last updated:** 2026-06-08 · **📊 15 fields** per record · one record per theme · OP and ED coverage

Turn the AnimeThemes.moe catalog into clean, structured records you can drop into a music database, a playlist builder, or an anime companion app. Search by anime name, or browse a whole season and year, and get one row per theme with the anime cover, the song title, the performing artists, and links to the actual audio and video files.

Coverage is the public AnimeThemes.moe library: opening and ending themes for thousands of anime across decades of seasons, each theme carrying its type (OP or ED), its slug (OP1, ED2, and so on), the song, the artists who performed it, and the hosted media for that theme.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Anime music fans and collectors | Build a personal library of OP and ED songs |
| Playlist and app builders | Seed a database with themes, artists, and media links |
| Discord and Telegram bot developers | Answer "what is the opening of X" queries |
| Researchers and data analysts | Study anime music trends across seasons and years |

### 📋 What the AnimeThemes Anime Songs Scraper does

This Actor calls the public AnimeThemes.moe API and returns one clean record per theme:

- **Anime context** — name, slug, season, year, and media format.
- **Theme details** — type (OP or ED), slug like OP1 or ED2, and sequence number.
- **Song details** — song title and the list of performing artists.
- **Media** — direct video link, audio link, and the video resolution.

You can search by anime name, or filter by season and year, and you control how many records come back. Every record leads with the anime cover image and carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `search` | string | Anime name to search for, for example `Naruto`. Leave empty to browse by season and year. |
| `season` | select | Limit to a season. One of `Winter`, `Spring`, `Summer`, `Fall`, or any. |
| `year` | integer | Limit to a release year, for example `2020`. |
| `maxItems` | integer | How many theme records to return. Free plan is capped at 10. |

**Example 1 — every theme for one anime**
```json
{
    "search": "Bleach",
    "maxItems": 25
}
````

**Example 2 — a full season of themes**

```json
{
    "season": "Spring",
    "year": 2016,
    "maxItems": 200
}
```

> ⚠️ **Good to Know:** Some songs on AnimeThemes have no credited artist, so the `artists` array can be empty for those themes. The Actor passes through exactly what the source provides.

### 📊 Output

Each theme record looks like this:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Anime cover image (large cover when available) |
| 📺 `animeName` | Anime title |
| 🎵 `themeType` | Theme type, OP or ED |
| 🏷 `themeSlug` | Theme slug, for example OP1 or ED2 |
| 🎶 `songTitle` | Song title |
| 🎤 `artists` | Array of performing artist names |
| 🔖 `animeSlug` | AnimeThemes anime slug |
| 🍂 `season` | Airing season |
| 📅 `year` | Release year |
| 📼 `mediaFormat` | Media format, for example TV |
| 🔢 `sequence` | Theme sequence number |
| 📐 `resolution` | Video resolution in pixels |
| 🎬 `videoLink` | Direct link to the theme video |
| 🔊 `audioLink` | Direct link to the theme audio |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — opening theme**

```json
{
    "imageUrl": "https://pub-92474f7785774e91a790e086dfa6b2ef.r2.dev/anime/large-cover/ZDNvEtoikjQ2NkyCzPmB3xQQvPrQnYbAUiLgmxh8.png",
    "animeName": "Bleach",
    "themeType": "OP",
    "themeSlug": "OP1",
    "songTitle": "*~Asterisk",
    "artists": [],
    "animeSlug": "bleach",
    "season": "Fall",
    "year": 2004,
    "mediaFormat": "TV",
    "sequence": 1,
    "resolution": 528,
    "videoLink": "https://v.animethemes.moe/Bleach-OP1.webm",
    "audioLink": "https://a.animethemes.moe/Bleach-OP1.ogg",
    "scrapedAt": "2026-06-08T22:07:21.248Z",
    "error": null
}
```

**Real sample — opening theme with artist**

```json
{
    "imageUrl": "https://pub-92474f7785774e91a790e086dfa6b2ef.r2.dev/anime/large-cover/XIkHCEhRT62vHro6GZjy0oLDFigeYnnPKllUNtZR.jpg",
    "animeName": "12-sai.: Chicchana Mune no Tokimeki",
    "themeType": "OP",
    "themeSlug": "OP1",
    "songTitle": "Sweet Sensation",
    "artists": ["Rie Murakawa"],
    "animeSlug": "12_sai_chicchana_mune_no_tokimeki",
    "season": "Spring",
    "year": 2016,
    "mediaFormat": "TV",
    "sequence": null,
    "resolution": 720,
    "videoLink": "https://v.animethemes.moe/12Sai-OP1.webm",
    "audioLink": "https://a.animethemes.moe/12Sai-OP1.ogg",
    "scrapedAt": "2026-06-08T22:08:04.300Z",
    "error": null
}
```

**Real sample — ending theme**

```json
{
    "imageUrl": "https://pub-92474f7785774e91a790e086dfa6b2ef.r2.dev/anime/large-cover/DBibwSqcnZEqzxncGHrOvq8YYnaNWQ3E2p5SehoF.jpg",
    "animeName": "100-man no Inochi no Ue ni Ore wa Tatteiru",
    "themeType": "ED",
    "themeSlug": "ED1",
    "songTitle": "Carpe Diem",
    "artists": ["Liyuu"],
    "animeSlug": "100_man_no_inochi_no_ue_ni_ore_wa_tatteiru",
    "season": "Fall",
    "year": 2020,
    "mediaFormat": "TV",
    "sequence": null,
    "resolution": 720,
    "videoLink": "https://v.animethemes.moe/100Man-ED1.webm",
    "audioLink": "https://a.animethemes.moe/100Man-ED1.ogg",
    "scrapedAt": "2026-06-08T22:08:04.300Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per theme, with the anime cover placed first for instant previews.
- Both audio and video links per theme, pointing at the actual hosted media files.
- Artists come as a ready-to-use array, not a tangled nested object.
- Search by name or browse a whole season and year in one run.
- No account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Media links included | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Hand-copying from a wiki | Hours | Inconsistent | Manual | Constant |
| Writing your own API client | Days | Depends | Manual | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the AnimeThemes Anime Songs Scraper.
3. Enter an anime name in `search`, or set a `season` and `year`.
4. Set `maxItems` to the number of theme records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Music apps and playlists

| Goal | How this helps |
|---|---|
| Build an anime OP and ED library | Pull themes with song titles and media links |
| Keep playlists current | Re-run for a new season when it airs |

#### Companion tools and bots

| Goal | How this helps |
|---|---|
| Power a Discord lookup bot | Feed it themes, artists, and audio links |
| Build a "name that opening" game | Use audio links and song titles |

#### Analytics and research

| Goal | How this helps |
|---|---|
| Study music trends by season | Group themes by season and year |
| Track artist output | Aggregate themes by performing artist |

#### Content creation

| Goal | How this helps |
|---|---|
| Source clips for videos | Use the direct video links |
| Build season recap pages | Start from a complete season of themes |

### 🔌 Automating AnimeThemes Anime Songs Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how anime music styles change across decades.
- **Personal:** build your own OP and ED collection.
- **Non-profit:** power a community anime music resource.
- **Experimentation:** prototype a music app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to group themes by artist, build a season playlist, or find every OP from a given year.

### ❓ Frequently Asked Questions

**Do I need an AnimeThemes account?**
No. The Actor reads the public AnimeThemes.moe API, which needs no login.

**Do I need an API key?**
No key is required.

**Can I search by anime name?**
Yes. Put a name in the `search` field and the Actor returns matching anime and their themes.

**Can I browse a whole season?**
Yes. Set `season` and `year` and leave `search` empty to pull every matching anime.

**What is one record?**
One theme. Each opening and each ending of an anime is its own record, so an anime with three OPs and two EDs yields five records.

**Why is the artists array sometimes empty?**
Some songs on AnimeThemes have no credited artist. The Actor returns an empty array rather than inventing data.

**Do I get the actual audio and video?**
You get direct links to the hosted media files for each theme, both an audio link and a video link.

**What does the theme slug mean?**
It identifies the theme within the anime, for example OP1 for the first opening or ED2 for the second ending.

**How fresh is the data?**
Each run pulls live from AnimeThemes, so it reflects the catalog at run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot a season or a search on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Brawlify Brawl Stars Database Scraper](https://apify.com/parseforge)
- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- More reference and media data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with AnimeThemes.moe. Only publicly available data is collected.

# Actor input Schema

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

Anime name to search for, for example 'Naruto' or 'Attack on Titan'. Leave empty to browse by season and year instead.

## `season` (type: `string`):

Only return anime that aired in this season. Leave as 'Any' to skip this filter.

## `year` (type: `integer`):

Only return anime that aired in this year, for example 2020. Leave empty to skip this filter.

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

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

## Actor input object example

```json
{
  "season": "",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/animethemes-anime-songs-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 }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AnimeThemes Anime Songs Scraper",
        "description": "Pull anime opening and ending themes from AnimeThemes.moe with anime name, season, year, theme type like OP or ED, song title, performing artists, and direct audio and video links. Filter by name, season, or year. Useful for building playlists, music research, and anime databases.",
        "version": "0.1",
        "x-build-id": "bfxqKD5yAjR7KpG1E"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~animethemes-anime-songs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-animethemes-anime-songs-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~animethemes-anime-songs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-animethemes-anime-songs-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~animethemes-anime-songs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-animethemes-anime-songs-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": {
                    "search": {
                        "title": "Search",
                        "type": "string",
                        "description": "Anime name to search for, for example 'Naruto' or 'Attack on Titan'. Leave empty to browse by season and year instead."
                    },
                    "season": {
                        "title": "Season",
                        "enum": [
                            "",
                            "Winter",
                            "Spring",
                            "Summer",
                            "Fall"
                        ],
                        "type": "string",
                        "description": "Only return anime that aired in this season. Leave as 'Any' to skip this filter.",
                        "default": ""
                    },
                    "year": {
                        "title": "Year",
                        "minimum": 1960,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only return anime that aired in this year, for example 2020. Leave empty to skip this filter."
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
