# MyAnimeList Scraper (`parseforge/myanimelist-scraper`) Actor

Scrape anime and manga rankings from MyAnimeList. Get top-ranked titles with scores, genres, episodes, studios, synopsis, and member counts. Search by keyword or browse top charts. Filter by type, status, rating, minimum score, and sort order across 20,000+ titles.

- **URL**: https://apify.com/parseforge/myanimelist-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Lead generation, Other
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

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

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

## 🎌 MyAnimeList Scraper

> 🚀 **Export anime and manga rankings, scores, genres, and synopsis from MyAnimeList in seconds.** Pull the complete top list or search by title - no API key, no login, no rate-limit headaches.

> 🕒 **Last updated:** 2026-05-21 · **📊 23 fields** per record · **🎌 30,000+ anime titles** · **🌏 Global coverage** · **📚 Anime & Manga**

The **MyAnimeList Scraper** pulls structured anime and manga data from the world's largest anime/manga database via the public Jikan API. It returns **23 fields per record**, including title, score, rank, popularity, genres, studios, synopsis, airing dates, and episode count. Data is collected in real time on every run.

The catalog covers tens of thousands of anime and manga titles spanning every genre, studio, and era. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in under a minute. No manual clicking, no copy-paste, no data engineering required.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Anime fans, data scientists, recommendation system builders, content researchers, entertainment analysts, otaku hobbyists | Recommendation engines, anime research, genre analysis, studio comparisons, score tracking, content cataloging |

---

### 📋 What the MyAnimeList Scraper does

Two core workflows in a single run:

- 🏆 **Top list export.** Fetch the all-time highest-rated anime or manga, ordered by community score.
- 🔍 **Search by title.** Search for specific shows or manga like "Naruto", "One Piece", or "Attack on Titan".

Each record includes title (English + Japanese), score, rank, popularity, member count, genres, studios, synopsis, source material, duration, age rating, and airing dates.

> 💡 **Why it matters:** MyAnimeList hosts one of the most comprehensive anime and manga databases on the internet. Scraping it manually is tedious and fragile. This Actor wraps the Jikan API cleanly and gives you structured, downloadable data in seconds.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>contentType</td><td>select</td><td>anime</td><td>Whether to scrape anime or manga.</td></tr>
<tr><td>searchQuery</td><td>string</td><td>""</td><td>Search by title (e.g. "Naruto"). Leave empty to get the all-time top list.</td></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: Top 25 anime**

```json
{
    "contentType": "anime",
    "maxItems": 25
}
````

**Example: Search for Naruto**

```json
{
    "contentType": "anime",
    "searchQuery": "Naruto",
    "maxItems": 10
}
```

> ⚠️ **Good to Know:** The Jikan API enforces a 3 requests/second rate limit. The scraper respects this automatically with a 350ms delay between requests. For large `maxItems` values, the run may take a few minutes.

***

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Large cover image URL from MyAnimeList CDN |
| 📺 `title` | string | English title (falls back to romaji) |
| 🇯🇵 `titleJapanese` | string | Original Japanese title |
| 🔗 `url` | string | Direct link to the MyAnimeList entry |
| 🆔 `malId` | integer | MyAnimeList unique identifier |
| 📋 `type` | string | TV, Movie, OVA, ONA, Special, etc. |
| 🎬 `episodes` | integer | Total episode count (null if ongoing) |
| 📡 `status` | string | Finished Airing, Currently Airing, etc. |
| ⭐ `score` | number | Community score out of 10 |
| 👥 `scoredBy` | integer | Number of users who rated this |
| 🏆 `rank` | integer | All-time rank by score |
| 📈 `popularity` | integer | Popularity rank by member count |
| 👤 `members` | integer | Total users tracking this title |
| 🎭 `genres` | array | Genre names (Action, Romance, Fantasy...) |
| 🏢 `studios` | array | Animation studio names |
| 📝 `synopsis` | string | Full plot summary |
| 📚 `source` | string | Source material: Manga, Light novel, Original, etc. |
| ⏱️ `duration` | string | Episode runtime (e.g. "24 min per ep") |
| 🔞 `rating` | string | Age rating: G, PG, PG-13, R-17+, etc. |
| 📅 `airedFrom` | string | ISO date when airing started |
| 📅 `airedTo` | string | ISO date when airing ended (null if ongoing) |
| 🕒 `scrapedAt` | string | Collection timestamp |
| ❌ `error` | string | Error message if scraping failed |

**Sample record:**

```json
{
    "imageUrl": "https://cdn.myanimelist.net/images/anime/1015/138006l.jpg",
    "title": "Frieren: Beyond Journey's End",
    "titleJapanese": "葬送のフリーレン",
    "url": "https://myanimelist.net/anime/52991/Sousou_no_Frieren",
    "malId": 52991,
    "type": "TV",
    "episodes": 28,
    "status": "Finished Airing",
    "score": 9.27,
    "scoredBy": 888890,
    "rank": 1,
    "popularity": 104,
    "members": 1442906,
    "genres": ["Adventure", "Award Winning", "Drama", "Fantasy"],
    "studios": ["Madhouse"],
    "synopsis": "During their decade-long quest to defeat the Demon King...",
    "source": "Manga",
    "duration": "24 min per ep",
    "rating": "PG-13 - Teens 13 or older",
    "airedFrom": "2023-09-29T00:00:00+00:00",
    "airedTo": "2024-03-22T00:00:00+00:00",
    "scrapedAt": "2026-05-21T01:53:49.471Z",
    "error": null
}
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🌐 Public API - no auth | Zero setup. No API keys, no accounts, no scraping restrictions. |
| 🏆 Top list + search | Get the all-time top anime OR search for any specific title. |
| 📚 Anime AND manga | One actor covers both content types. |
| 📊 23 fields per record | Complete data including score, rank, genres, studios, synopsis, and dates. |
| ⚡ Respects rate limits | Built-in 350ms delay prevents getting blocked by Jikan API. |
| 🔄 Real-time data | All data collected live on every run - no stale cache. |

***

### 📈 How it compares to alternatives

| | MyAnimeList Scraper | Manual Export | Custom Script |
|---|---|---|---|
| Setup time | < 2 min | N/A | Hours |
| No coding required | ✅ | ✅ | ❌ |
| Scheduled runs | ✅ | ❌ | Complex |
| Anime + manga | ✅ | Partial | Custom |
| CSV / Excel / JSON | ✅ | ❌ | Custom |
| Rate limit handling | ✅ | N/A | Manual |

***

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify.
2. Open the **MyAnimeList Scraper** actor page.
3. Set `contentType` to `anime` or `manga`.
4. Optionally enter a `searchQuery` (leave blank for top list).
5. Set `maxItems` (free: up to 10, paid: up to 1,000,000).
6. Click **Start** and wait for the run to finish.
7. Download your dataset as **CSV, Excel, JSON, or XML**.

***

### 💼 Business use cases

#### 📊 Recommendation Engines

Build anime recommendation systems powered by real MAL scores, genres, and member counts. Use genre overlap and score thresholds to suggest titles users haven't watched yet.

#### 🔍 Market Research

Analyze which studios produce the highest-rated content, which genres dominate by era, and which shows have the largest fanbase relative to their score rank.

#### 🎓 Academic Research

Study the relationship between source material (manga vs. light novel vs. original) and audience reception. Track how scores evolve for ongoing vs. finished series.

#### 🛒 Content Cataloging

Maintain a structured anime database for streaming platforms, merchandise sites, or fan wikis. Keep metadata current by scheduling runs weekly or monthly.

***

### 🔌 Automating MyAnimeList Scraper

Connect this Actor to your favorite tools using Apify's integrations:

- **Make (Integromat)** - Trigger a run when a new season starts and send results to Google Sheets.
- **Zapier** - Automatically add newly discovered top anime to an Airtable database.
- **Slack** - Get a weekly digest of the top 10 anime sent to your team channel.
- **Google Sheets** - Schedule weekly exports and always have a fresh anime dataset.
- **REST API** - Trigger runs programmatically and fetch results via the Apify API.

***

### 🌟 Beyond business use cases

#### 🎓 Research & Education

Study community scoring patterns, genre trends over decades, or the correlation between production studio and audience reception scores.

#### 🎨 Creative Projects

Build anime recommendation bots, trivia games, or quiz apps powered by real MAL data including synopsis and genre tags.

#### 🌍 Non-profit & Fandom

Power fan wikis, community rankings, or accessibility tools that make anime discovery easier for newcomers to the medium.

#### 🧪 Experimentation

Test NLP models on anime synopses, build genre classifiers, or prototype recommendation algorithms on real community-scored data.

***

### 🤖 Ask an AI assistant about this scraper

Not sure which inputs to use? Paste this into any AI assistant:

> "I want to use the MyAnimeList Scraper on Apify to collect anime data. It uses the Jikan API. I can set contentType (anime or manga), searchQuery (optional title search), and maxItems. What inputs should I use for \[your use case]?"

***

### ❓ Frequently Asked Questions

**❓ Does this require an API key or MyAnimeList account?**
No. It uses the public Jikan API which requires no authentication.

**❓ How many anime titles can I scrape?**
Free users: up to 10. Paid users: up to 1,000,000.

**❓ Can I search for specific anime?**
Yes. Set `searchQuery` to any title like "Naruto", "One Piece", or "Attack on Titan".

**❓ Can I get manga data too?**
Yes. Set `contentType` to `manga` to get manga records with chapters, volumes, and author fields instead of episodes and studios.

**❓ Why does it take longer for large requests?**
The Jikan API has a 3 requests/second rate limit. The scraper adds a 350ms delay between page fetches to stay compliant.

**❓ Are the scores real-time?**
Yes. Every run fetches fresh data from the Jikan API, which mirrors MyAnimeList scores updated regularly.

**❓ What is the `rank` field?**
The all-time ranking by weighted community score on MyAnimeList. Rank 1 is the highest-rated anime ever.

**❓ What is the `popularity` field?**
Ranking by number of members tracking a title. Popular titles have low popularity numbers (1 = most popular).

**❓ Can I filter by genre?**
The `genre` input is supported. You can pass a genre name like "Action" or "Romance" to filter results. Note: genre filtering works best combined with a search query.

**❓ What happens if a field is null?**
Some fields like `episodes` and `airedTo` are null for ongoing series. `score` may be null for very new or obscure titles with few ratings.

**❓ Is this scraper updated regularly?**
The actor uses the live Jikan API on every run, so data always reflects current MyAnimeList standings.

***

### 🔌 Integrate with any app

Export your dataset and connect to:

**Spreadsheets:** Google Sheets, Microsoft Excel, Apple Numbers
**Databases:** PostgreSQL, MySQL, MongoDB, Supabase, Airtable
**BI Tools:** Tableau, Power BI, Looker, Metabase
**Automation:** Make, Zapier, n8n, Pipedream
**Cloud Storage:** AWS S3, Google Cloud Storage, Dropbox
**APIs:** Apify REST API, webhooks, actor-to-actor integrations

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Goodreads Scraper](https://apify.com/parseforge/goodreads-scraper) | Export book ratings, reviews, and metadata from Goodreads |
| [Metacritic Scraper](https://apify.com/parseforge/metacritic-scraper) | Scrape game, movie, and TV scores from Metacritic |
| [Letterboxd Scraper](https://apify.com/parseforge/letterboxd-scraper) | Collect film ratings and reviews from Letterboxd |
| [RAWG Scraper](https://apify.com/parseforge/rawg-scraper) | Export video game data from the RAWG games database |
| [BoardGameGeek Scraper](https://apify.com/parseforge/boardgamegeek-scraper) | Scrape board game rankings and reviews from BGG |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) to find scrapers for hundreds of popular websites - all maintained, documented, and ready to run.

***

*This Actor is an independent tool and is not affiliated with, endorsed by, or officially connected to MyAnimeList or the Jikan API team. All data is publicly accessible and retrieved via the open Jikan API.*

# Actor input Schema

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

Whether to scrape anime or manga

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

Search by title (e.g. 'Naruto', 'One Piece', 'Attack on Titan'). Leave empty to get the all-time top list.

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

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

## Actor input object example

```json
{
  "contentType": "anime",
  "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/myanimelist-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/myanimelist-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/myanimelist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyAnimeList Scraper",
        "description": "Scrape anime and manga rankings from MyAnimeList. Get top-ranked titles with scores, genres, episodes, studios, synopsis, and member counts. Search by keyword or browse top charts. Filter by type, status, rating, minimum score, and sort order across 20,000+ titles.",
        "version": "0.1",
        "x-build-id": "8Ux0GLAbbtoYcVeIL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~myanimelist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-myanimelist-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~myanimelist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-myanimelist-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~myanimelist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-myanimelist-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": {
                    "contentType": {
                        "title": "Content Type",
                        "enum": [
                            "anime",
                            "manga"
                        ],
                        "type": "string",
                        "description": "Whether to scrape anime or manga",
                        "default": "anime"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search by title (e.g. 'Naruto', 'One Piece', 'Attack on Titan'). Leave empty to get the all-time top list."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
