# Kitsu Anime & Manga Scraper (`parseforge/kitsu-anime-manga-scraper`) Actor

Search the Kitsu catalog by keyword for anime and manga. Pull the poster image, canonical and Japanese titles, synopsis, average rating, rating rank, popularity rank, status, and start date. Useful for building a media database, recommendation app, or franchise research.

- **URL**: https://apify.com/parseforge/kitsu-anime-manga-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, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.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)

## 🎴 Kitsu Anime & Manga Scraper

> 🚀 **Turn any anime or manga search into a clean, structured catalog in seconds.** Search Kitsu by keyword and pull posters, titles, ratings, ranks, and synopses for every match.

> 🕒 **Last updated:** 2026-06-04 · **📊 23 fields** per record · Anime and manga catalogs · Powered by the public Kitsu database

Looking up anime and manga details one page at a time is slow. This Actor lets you search the Kitsu catalog by a text query, choose anime or manga, and collect every matching title with its poster image, canonical and localized titles, rating, popularity rank, status, air or publication dates, and full synopsis.

It covers both the anime side (TV, movies, OVA, ONA, specials, music) and the manga side (manga, novels, one shots, doujin), so you can build a media database, enrich a recommendation app, or research a franchise without copy and paste.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Anime and manga app builders | Populate a title database with posters and ratings |
| Data analysts and researchers | Study ratings, popularity, and release trends |
| Content creators and bloggers | Pull synopses and artwork for write ups |
| Recommendation engine developers | Seed a catalog with structured metadata |
| Hobbyists and collectors | Track favorites, ranks, and release dates |

### 📋 What the Kitsu Anime & Manga Scraper does

- Searches the Kitsu anime or manga catalog by any text query.
- Returns every matching title with a poster image first.
- Captures canonical, English, and Japanese titles for each record.
- Pulls rating, rating rank, popularity rank, status, and age rating.
- Includes start and end dates, episode count, chapter count, and volume count where available.
- Adds the full synopsis, favorites count, user count, and a cover image.
- Lets you sort by relevance, highest rated, most popular, newest, or oldest.

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

### ⚙️ Input

| Field | Key | Type | Required | Description |
|---|---|---|---|---|
| 🔎 Search Query | `query` | string | Yes | Text to search for. Matches against titles. |
| 🎬 Media Type | `mediaType` | select | Yes | Search anime or manga. |
| 🔢 Max Items | `maxItems` | integer | No | Cap on records returned. Free plan is limited to 10. |
| ↕️ Sort Order | `sort` | select | No | Relevance, highest rated, most popular, newest, or oldest. |

**Example 1 — Highest rated anime for a franchise**
```json
{
    "query": "naruto",
    "mediaType": "anime",
    "maxItems": 6,
    "sort": "-averageRating"
}
````

**Example 2 — Manga search by title**

```json
{
    "query": "berserk",
    "mediaType": "manga",
    "maxItems": 5
}
```

> ⚠️ **Good to Know:** Kitsu matches your query against title text, so broad terms return many results while exact titles return the closest match first. Some fields are conditional. Ongoing series have a null end date, manga episode counts do not apply, and titles that are not yet ranked have a null rating or popularity rank.

### 📊 Output

Each record follows this schema. Field order is consistent across anime and manga, with anime adding `episodeCount` and manga adding `chapterCount` and `volumeCount`.

| Field | Key | Description |
|---|---|---|
| 🖼 Image | `imageUrl` | Poster image URL (highest available resolution) |
| 📌 Title | `title` | Canonical title |
| 🎬 Media Type | `mediaType` | anime or manga |
| 📡 Status | `status` | finished, current, upcoming, and similar |
| 🔗 URL | `url` | Kitsu page for the title |
| 🆔 ID | `id` | Kitsu record ID |
| 🔧 Slug | `slug` | URL slug |
| 🇬🇧 English Title | `englishTitle` | English title when available |
| 🇯🇵 Japanese Title | `japaneseTitle` | Japanese title when available |
| 🏷 Subtype | `subtype` | TV, movie, OVA, manga, novel, and similar |
| 📝 Synopsis | `synopsis` | Full description |
| 🔞 Age Rating | `ageRating` | G, PG, R, R18 when available |
| ⭐ Average Rating | `averageRating` | Average score as a percentage string |
| 🏆 Rating Rank | `ratingRank` | Rank by rating, null when unranked |
| 🔥 Popularity Rank | `popularityRank` | Rank by popularity, null when unranked |
| 📅 Start Date | `startDate` | First air or publication date |
| 🏁 End Date | `endDate` | Final date, null for ongoing |
| 📺 Episode Count | `episodeCount` | Anime only, null when unknown |
| 📚 Chapter Count | `chapterCount` | Manga only, null when unknown |
| 📦 Volume Count | `volumeCount` | Manga only, null when unknown |
| ❤️ Favorites Count | `favoritesCount` | Number of users who favorited the title |
| 👥 User Count | `userCount` | Number of users tracking the title |
| 🎨 Cover Image | `coverImageUrl` | Wide cover image when available |
| 🕒 Scraped At | `scrapedAt` | Collection timestamp |
| ❌ Error | `error` | Null on success |

**Real sample — anime (Naruto: Shippuuden)**

```json
{
    "imageUrl": "https://media.kitsu.app/anime/poster_images/1555/original.jpg",
    "title": "Naruto: Shippuuden",
    "mediaType": "anime",
    "status": "finished",
    "url": "https://kitsu.io/anime/naruto-shippuden",
    "id": "1555",
    "slug": "naruto-shippuden",
    "englishTitle": "Naruto: Shippuden",
    "japaneseTitle": "ナルト- 疾風伝",
    "subtype": "TV",
    "ageRating": "PG",
    "averageRating": "84.06",
    "ratingRank": 55,
    "popularityRank": 28,
    "startDate": "2007-02-15",
    "endDate": "2017-03-23",
    "episodeCount": 500,
    "favoritesCount": 5737,
    "userCount": 214319,
    "scrapedAt": "2026-06-04T19:28:26.291Z",
    "error": null
}
```

**Real sample — anime special (ROAD OF NARUTO)**

```json
{
    "imageUrl": "https://media.kitsu.app/anime/46581/poster_image/3a081de040827280c49233c5c6e0dfff.png",
    "title": "ROAD OF NARUTO",
    "mediaType": "anime",
    "status": "finished",
    "url": "https://kitsu.io/anime/road-of-naruto",
    "id": "46581",
    "slug": "road-of-naruto",
    "subtype": "special",
    "averageRating": "82.76",
    "ratingRank": 121,
    "popularityRank": 1678,
    "startDate": "2022-10-03",
    "endDate": "2022-10-03",
    "episodeCount": 1,
    "favoritesCount": 9,
    "userCount": 9880,
    "scrapedAt": "2026-06-04T19:28:26.348Z",
    "error": null
}
```

**Real sample — manga (Berserk)**

```json
{
    "imageUrl": "https://media.kitsu.app/manga/8/poster_image/67d602c20d1bf0eeb43e1a363c59ed5b.jpg",
    "title": "Berserk",
    "mediaType": "manga",
    "status": "current",
    "url": "https://kitsu.io/manga/berserk",
    "id": "8",
    "slug": "berserk",
    "japaneseTitle": "ベルセルク",
    "subtype": "manga",
    "ageRating": "R",
    "averageRating": "84.89",
    "ratingRank": 5,
    "popularityRank": 17,
    "startDate": "1989-08-25",
    "endDate": null,
    "chapterCount": null,
    "volumeCount": 0,
    "favoritesCount": 3991,
    "userCount": 58027,
    "scrapedAt": "2026-06-04T19:28:49.569Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Poster image comes first in every record, ready to display in a gallery or card.
- Both anime and manga from a single search input.
- Localized titles in English and Japanese alongside the canonical title.
- Ratings, rating rank, and popularity rank for ranking and comparison.
- Honest fields. Conditional values are returned as null rather than fabricated.
- No API key, no login, no proxy setup required.

### 📈 How it compares to alternatives

| Approach | Coverage | Images | Structured fields | Effort |
|---|---|---|---|---|
| This Actor | Anime and manga | Poster and cover | 23 fields | Run and collect |
| Manual lookup on Kitsu | One title at a time | Yes | Copy by hand | High |
| Generic web crawler | Whole pages | Mixed | Needs parsing | High |
| Building your own client | Depends | Depends | You map every field | Very high |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Kitsu Anime & Manga Scraper and enter a search query.
3. Choose anime or manga, set a sort order, and pick how many records you want.
4. Click Start and watch records stream into the dataset.
5. Browse the results in the table view or pull them into your own app.

### 💼 Business use cases

**Media and entertainment apps**
| Need | How this helps |
|---|---|
| Seed a catalog | Pull posters, titles, and ratings in one run |
| Keep status current | Refresh ongoing versus finished status |

**Analytics and research**
| Need | How this helps |
|---|---|
| Study popularity | Compare rating rank and popularity rank |
| Track release trends | Use start and end dates across titles |

**Content and marketing**
| Need | How this helps |
|---|---|
| Write reviews and roundups | Grab synopses and artwork quickly |
| Build franchise pages | Collect every title under a keyword |

**Recommendation systems**
| Need | How this helps |
|---|---|
| Feature engineering | Use ratings, favorites, and user counts |
| Content similarity | Match on subtype, age rating, and synopsis |

### 🔌 Automating Kitsu Anime & Manga 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 new search results to a channel.
- **Airbyte** to sync the dataset into a warehouse.
- **GitHub** Actions to schedule recurring searches.
- **Google Drive** to archive each run as a stored result.

### 🌟 Beyond business use cases

- **Research:** analyze how ratings and popularity shift across a franchise.
- **Personal:** build your own watchlist or reading list with artwork.
- **Non-profit:** power a community library or fan wiki with clean metadata.
- **Experimentation:** train or test a recommendation model on real titles.

### 🤖 Ask an AI assistant

Paste your collected records into an assistant and ask away:

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

Try prompts like "rank these anime by popularity" or "summarize the franchise from these synopses".

### ❓ Frequently Asked Questions

**Does this work for both anime and manga?**
Yes. Pick the media type in the input and the search runs against that catalog.

**Do I need a Kitsu API key?**
No. The Kitsu catalog used here is public and needs no key or login.

**How does the search match titles?**
Kitsu matches your query against title text, including English and Japanese titles, and returns the closest matches first.

**Why is the end date null on some records?**
Ongoing series do not have an end date yet, so that field is returned as null.

**Why are some ratings or ranks null?**
Titles that have not gathered enough activity are not ranked, so rating rank and popularity rank can be null.

**What image do I get?**
The poster image comes first as `imageUrl`, and a wider cover image is included as `coverImageUrl` when available.

**Can I limit the number of results?**
Yes. Set the max items value. Free plans are capped at 10 records.

**How do I sort the results?**
Choose relevance, highest rated, most popular, newest, or oldest in the input.

**Does it include the synopsis?**
Yes. The full synopsis text is included for each title.

**How fresh is the data?**
Each run reads the Kitsu catalog live, so values reflect the catalog at run time.

**Is the data accurate?**
Values come straight from Kitsu. Conditional fields are returned as null rather than guessed.

**Can I run this on a schedule?**
Yes. Use Apify scheduling or any of the automation options above.

### 🔌 Integrate with any app

Records are available through the dataset, so you can pull them into a spreadsheet, a database, an internal tool, or any service that reads from an Apify dataset.

### 🔗 Recommended Actors

- [AniList Anime & Manga Scraper](https://apify.com/parseforge/anilist-anime-manga-scraper)
- [MyAnimeList Scraper](https://apify.com/parseforge/myanimelist-scraper)
- [MangaDex Titles Scraper](https://apify.com/parseforge/mangadex-titles-scraper)
- [TMDB Movies & TV Scraper](https://apify.com/parseforge/tmdb-movies-tv-scraper)
- [JustWatch Streaming Scraper](https://apify.com/parseforge/justwatch-streaming-scraper)

> 💡 **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 Kitsu. Only publicly available data is collected.

# Actor input Schema

## `query` (type: `string`):

Text to search for on Kitsu. Matches against titles. Example: naruto, one piece, cowboy bebop.

## `mediaType` (type: `string`):

Whether to search the anime catalog or the manga catalog on Kitsu.

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

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

## `sort` (type: `string`):

How to order the search results returned by Kitsu.

## Actor input object example

```json
{
  "query": "naruto",
  "mediaType": "anime",
  "maxItems": 10,
  "sort": "relevance"
}
```

# 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 = {
    "query": "naruto",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/kitsu-anime-manga-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 = {
    "query": "naruto",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/kitsu-anime-manga-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 '{
  "query": "naruto",
  "maxItems": 10
}' |
apify call parseforge/kitsu-anime-manga-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kitsu Anime & Manga Scraper",
        "description": "Search the Kitsu catalog by keyword for anime and manga. Pull the poster image, canonical and Japanese titles, synopsis, average rating, rating rank, popularity rank, status, and start date. Useful for building a media database, recommendation app, or franchise research.",
        "version": "0.1",
        "x-build-id": "ZIJTx9yXhtR6FKtKn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~kitsu-anime-manga-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-kitsu-anime-manga-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~kitsu-anime-manga-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-kitsu-anime-manga-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~kitsu-anime-manga-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-kitsu-anime-manga-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": [
                    "query",
                    "mediaType"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Text to search for on Kitsu. Matches against titles. Example: naruto, one piece, cowboy bebop."
                    },
                    "mediaType": {
                        "title": "Media Type",
                        "enum": [
                            "anime",
                            "manga"
                        ],
                        "type": "string",
                        "description": "Whether to search the anime catalog or the manga catalog on Kitsu.",
                        "default": "anime"
                    },
                    "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"
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "relevance",
                            "-averageRating",
                            "-userCount",
                            "-startDate",
                            "startDate"
                        ],
                        "type": "string",
                        "description": "How to order the search results returned by Kitsu.",
                        "default": "relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```