# MyAnimeList Anime & Manga Intelligence Scraper (`automation-lab/myanimelist-anime-manga-intelligence-scraper`) Actor

Export MyAnimeList anime and manga search, rankings, seasons, details, characters, recommendations, and reviews through Jikan v4.

- **URL**: https://apify.com/automation-lab/myanimelist-anime-manga-intelligence-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## MyAnimeList Anime & Manga Intelligence Scraper

Export structured anime and manga catalog intelligence from MyAnimeList through the public Jikan v4 API.

Search titles, monitor top rankings, collect seasonal anime, or enrich exact MyAnimeList IDs with characters, recommendations, and reviews.

No MyAnimeList login, cookie, API key, browser, or proxy is required.

### What does MyAnimeList Anime & Manga Intelligence Scraper do?

This Actor turns MyAnimeList catalog data into clean JSON, CSV, Excel, XML, RSS, and Parquet exports.

Use four collection modes:

- 🔎 **Search** anime or manga by title or keyword.
- 🏆 **Top** export current top-ranked anime or manga.
- 📅 **Seasonal** collect anime from a year and broadcast season.
- 🎯 **IDs** enrich exact MyAnimeList catalog IDs.

Every row preserves the canonical MyAnimeList URL and the context that produced it.

### Who is it for?

#### Recommendation app builders

Create seed catalogs with scores, genres, themes, studios, and related-title recommendations.

#### Catalog and media data teams

Normalize anime and manga identifiers, multilingual titles, dates, formats, and status metadata.

#### Entertainment analysts

Track score, rank, popularity, member count, and favorites across scheduled runs.

#### Fan and research projects

Export reproducible seasonal or genre-oriented datasets without maintaining a custom Jikan client.

### Why use this Actor?

- ✅ One input contract for anime and manga.
- ✅ Stable normalized fields instead of deeply nested source JSON.
- ✅ Built-in pagination and exact `maxItems` control.
- ✅ Rate-aware requests with retry and backoff.
- ✅ Optional deep enrichment only when you need it.
- ✅ Native Apify datasets, schedules, webhooks, integrations, and API access.

### What MyAnimeList data can I extract?

| Group | Fields |
|---|---|
| Identity | `recordType`, `malId`, `url`, `title` |
| Titles | English, Japanese, and alternate title variants |
| Classification | format, source, status, rating |
| Progress | episodes, chapters, volumes, airing status |
| Dates | start date, end date, season, year, broadcast |
| Audience signals | score, scored-by count, rank, popularity, members, favorites |
| Editorial | synopsis and background |
| Organizations | studios, producers, licensors, serializations |
| Taxonomy | genres, explicit genres, themes, demographics |
| Media | poster images and trailer URL |
| Enrichment | characters, voice actors, recommendations, reviews |

### Choose a discovery mode

#### Keyword search

Set `mode` to `search`, choose `anime` or `manga`, and enter `query`.

Search is useful for franchises, topics, title fragments, and catalog discovery.

#### Top rankings

Set `mode` to `top` to export current ranked titles in source order.

Repeat the run on a schedule to compare ranking and audience changes.

#### Seasonal anime

Set `mode` to `seasonal`, then provide `year` and `season`.

Seasons are `winter`, `spring`, `summer`, and `fall`.

#### Exact MAL IDs

Set `mode` to `ids` and provide numeric MyAnimeList anime or manga IDs.

ID mode uses the full-detail endpoint and is ideal for enrichment pipelines.

### Input

Example keyword search:

```json
{
  "mode": "search",
  "recordType": "anime",
  "query": "cyberpunk",
  "maxItems": 25,
  "sfw": true
}
````

Example seasonal export:

```json
{
  "mode": "seasonal",
  "recordType": "anime",
  "year": 2025,
  "season": "spring",
  "maxItems": 100
}
```

Example exact manga lookup:

```json
{
  "mode": "ids",
  "recordType": "manga",
  "ids": [2, 13, 25],
  "maxItems": 3
}
```

### Optional enrichment

Enable only the nested data your workflow needs:

- `enrichCharacters` adds characters and anime voice actors.
- `enrichRecommendations` adds related titles and recommendation votes.
- `enrichReviews` adds recent review text, scores, tags, users, and reactions.

Each enrichment makes one additional Jikan request per title.

Use `maxCharacters`, `maxRecommendations`, and `maxReviews` to bound row size.

### Output

Each dataset item is one normalized title.

```json
{
  "recordType": "anime",
  "mode": "search",
  "malId": 52991,
  "url": "https://myanimelist.net/anime/52991/Sousou_no_Frieren",
  "title": "Sousou no Frieren",
  "titleEnglish": "Frieren: Beyond Journey's End",
  "format": "TV",
  "status": "Finished Airing",
  "episodes": 28,
  "score": 9.26,
  "rank": 1,
  "popularity": 15,
  "genres": [{ "id": 2, "name": "Adventure", "url": "..." }],
  "studios": [{ "id": 11, "name": "Madhouse", "url": "..." }],
  "scrapedAt": "2026-07-13T00:00:00.000Z"
}
```

Nullable fields remain explicit when MyAnimeList does not publish a value.

Optional enrichment properties appear only when requested.

### How much does it cost to scrape MyAnimeList?

The Actor uses pay-per-event pricing: a **$0.005** one-time start fee plus one `Title record` event for every dataset row saved.

| Apify tier | Price per title | 1,000 titles plus start |
|---|---:|---:|
| Free | $0.000077744 | about $0.083 |
| Bronze | $0.000067604 | about $0.073 |
| Silver | $0.000052731 | about $0.058 |
| Gold | $0.000040562 | about $0.046 |
| Platinum | $0.000027041 | about $0.032 |
| Diamond | $0.000018929 | about $0.024 |

Enrichment requests do not create extra result events; they enrich the same title row. Platform compute is included in PPE billing.

### Step-by-step guide

1. Open the Actor input page.
2. Choose a discovery mode.
3. Select anime or manga.
4. Fill the mode-specific keyword, IDs, or season.
5. Set a conservative `maxItems` while testing.
6. Enable optional enrichment if required.
7. Click **Start**.
8. Export the dataset or connect an integration.

### Scheduling a rankings monitor

Create an Apify schedule with `mode: top` and your desired result count.

Run daily or weekly, then compare `rank`, `score`, `popularity`, and `members` by `malId`.

A webhook can notify your pipeline whenever the run succeeds.

### Integrations

#### Google Sheets

Send each completed dataset to a spreadsheet for editorial planning or trend charts.

#### Webhooks

Trigger a database import, recommendation rebuild, or notification after each seasonal refresh.

#### Zapier and Make

Route new title rows into no-code workflows, dashboards, or content queues.

#### Cloud storage and warehouses

Download CSV, JSON, Excel, XML, RSS, or Parquet from the dataset API.

### JavaScript API usage

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/myanimelist-anime-manga-intelligence-scraper').call({
  mode: 'top',
  recordType: 'anime',
  maxItems: 100
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API usage

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/myanimelist-anime-manga-intelligence-scraper').call(
    run_input={
        'mode': 'search',
        'recordType': 'manga',
        'query': 'space opera',
        'maxItems': 50,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API usage

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~myanimelist-anime-manga-intelligence-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"ids","recordType":"anime","ids":[52991],"maxItems":1}'
```

### Use with Apify MCP

Connect the Actor to Claude and other MCP clients through Apify's MCP server.

Claude Code URL:

```text
https://mcp.apify.com?tools=automation-lab/myanimelist-anime-manga-intelligence-scraper
```

Example prompts:

- “Export the current top 100 anime with scores and studios.”
- “Find manga matching climate fiction and return genres and popularity.”
- “Enrich MAL ID 52991 with characters and recommendations.”

For Claude Desktop, add the Apify MCP server and pass the same Actor tool identifier.

### Tips for reliable results

- Start with 10–25 items while designing your workflow.
- Use exact IDs when you already know the catalog entities.
- Keep enrichment off for broad ranking exports unless required.
- Schedule large refreshes rather than launching many simultaneous runs.
- Deduplicate historical snapshots with `recordType` plus `malId`.

### Rate limits and performance

Jikan is a public community API with conservative rate limits.

This Actor serializes requests and waits between them.

A basic 100-title export usually needs only four list requests.

Enriching 100 titles with all three options requires roughly 300 additional requests and therefore takes much longer.

HTTP 429 and temporary 5xx responses are retried with bounded increasing delays.

### Limitations

- Seasonal discovery is available for anime, not manga.
- Data freshness and completeness depend on MyAnimeList and Jikan.
- Jikan may temporarily throttle high-volume requests.
- Optional reviews are limited to the first source page and your configured cap.
- The Actor does not access private user lists or account-only data.
- It does not download videos, manga pages, or copyrighted media.

### Troubleshooting

#### Why does search require a query?

`query` is mandatory only when `mode` is `search`. Use `top`, `seasonal`, or `ids` for discovery without a keyword.

#### Why is my enriched run slower?

Each selected enrichment adds one request for every title. Reduce `maxItems`, select fewer enrichment types, or use a smaller enrichment cap.

#### Why was an ID skipped?

The selected anime or manga record may not exist, or the ID may belong to the other record type. Confirm the MyAnimeList URL and `recordType`.

#### Why are some values null?

MyAnimeList does not publish every field for every title. Null preserves the difference between an unavailable value and a false or zero value.

### Legality: is it legal to scrape MyAnimeList data?

This Actor accesses public catalog data exposed anonymously by Jikan.

You are responsible for your use of the data and for complying with applicable terms, database rights, copyright, privacy rules, and local law.

Do not use review text or user information for harassment, profiling, or unlawful redistribution.

Consult legal counsel for regulated or commercial reuse questions.

### Data quality and provenance

Every row includes the canonical MyAnimeList URL and a `scrapedAt` timestamp.

The Actor does not invent scores, rankings, title translations, or review content.

Normalized arrays retain source entity IDs, names, and URLs where available.

For time-series analysis, store each run's dataset and compare stable MAL IDs.

### Related scrapers

Explore other public-data tools from [automation-lab](https://apify.com/automation-lab) for catalog enrichment, media discovery, and scheduled monitoring workflows.

Related actors are linked only after they are available in the automation-lab portfolio.

### FAQ

#### Does this Actor need a MyAnimeList account?

No. It uses anonymous public Jikan v4 endpoints.

#### Can I collect both anime and manga?

Yes. Run the Actor once per `recordType` and combine datasets using `recordType` plus `malId` as the compound key.

#### Can I export more than 25 records?

Yes. The Actor paginates until `maxItems` is reached or the source has no next page.

#### Are duplicate titles emitted?

No. Results are deduplicated by MAL ID within a run.

#### Can I retrieve characters and reviews together?

Yes. Enable both enrichment toggles. Expect longer execution because each toggle adds one request per title.

#### Can I run it on a schedule?

Yes. Apify schedules are ideal for seasonal catalogs and ranking monitors.

#### Which export formats are available?

Apify datasets support JSON, JSONL, CSV, Excel, XML, RSS, and Parquet.

### Support

If a valid public title fails, share the Actor run URL, input, selected mode, and expected MyAnimeList record.

Avoid including private credentials or unrelated personal data in support reports.

The run log records retries, missing IDs, saved title counts, and completion context for diagnosis.

# Actor input Schema

## `mode` (type: `string`):

Search by keyword, export top rankings, fetch a seasonal anime catalog, or look up exact MAL IDs.

## `recordType` (type: `string`):

Collect anime or manga title records. Seasonal mode supports anime only.

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

Title or phrase to search, for example Frieren, One Piece, or cyberpunk.

## `ids` (type: `array`):

Exact numeric anime or manga IDs used in ID lookup mode.

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

Four-digit year for seasonal anime mode.

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

Anime broadcast season for seasonal mode.

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

Stop after this many unique title records.

## `sfw` (type: `boolean`):

Ask Jikan to omit adult search and discovery results.

## `enrichCharacters` (type: `boolean`):

Fetch characters and voice actors for every title. Adds one API request per title.

## `maxCharacters` (type: `integer`):

Maximum character entries retained when character enrichment is enabled.

## `enrichRecommendations` (type: `boolean`):

Fetch related title recommendations for every result.

## `maxRecommendations` (type: `integer`):

Maximum recommendation entries retained per title.

## `enrichReviews` (type: `boolean`):

Fetch recent MyAnimeList reviews for every title.

## `maxReviews` (type: `integer`):

Maximum review entries retained per title.

## Actor input object example

```json
{
  "mode": "search",
  "recordType": "anime",
  "query": "Frieren",
  "ids": [
    52991
  ],
  "year": 2025,
  "season": "spring",
  "maxItems": 10,
  "sfw": true,
  "enrichCharacters": false,
  "maxCharacters": 10,
  "enrichRecommendations": false,
  "maxRecommendations": 10,
  "enrichReviews": false,
  "maxReviews": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "recordType": "anime",
    "query": "Frieren",
    "ids": [
        52991
    ],
    "year": 2025,
    "season": "spring",
    "maxItems": 10,
    "sfw": true,
    "enrichCharacters": false,
    "maxCharacters": 10,
    "enrichRecommendations": false,
    "maxRecommendations": 10,
    "enrichReviews": false,
    "maxReviews": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/myanimelist-anime-manga-intelligence-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 = {
    "mode": "search",
    "recordType": "anime",
    "query": "Frieren",
    "ids": [52991],
    "year": 2025,
    "season": "spring",
    "maxItems": 10,
    "sfw": True,
    "enrichCharacters": False,
    "maxCharacters": 10,
    "enrichRecommendations": False,
    "maxRecommendations": 10,
    "enrichReviews": False,
    "maxReviews": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/myanimelist-anime-manga-intelligence-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 '{
  "mode": "search",
  "recordType": "anime",
  "query": "Frieren",
  "ids": [
    52991
  ],
  "year": 2025,
  "season": "spring",
  "maxItems": 10,
  "sfw": true,
  "enrichCharacters": false,
  "maxCharacters": 10,
  "enrichRecommendations": false,
  "maxRecommendations": 10,
  "enrichReviews": false,
  "maxReviews": 5
}' |
apify call automation-lab/myanimelist-anime-manga-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyAnimeList Anime & Manga Intelligence Scraper",
        "description": "Export MyAnimeList anime and manga search, rankings, seasons, details, characters, recommendations, and reviews through Jikan v4.",
        "version": "0.1",
        "x-build-id": "iVrIHm7wlmaAW5e39"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~myanimelist-anime-manga-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-myanimelist-anime-manga-intelligence-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/automation-lab~myanimelist-anime-manga-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-myanimelist-anime-manga-intelligence-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/automation-lab~myanimelist-anime-manga-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-myanimelist-anime-manga-intelligence-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": {
                    "mode": {
                        "title": "🎯 Discovery mode",
                        "enum": [
                            "search",
                            "top",
                            "seasonal",
                            "ids"
                        ],
                        "type": "string",
                        "description": "Search by keyword, export top rankings, fetch a seasonal anime catalog, or look up exact MAL IDs.",
                        "default": "search"
                    },
                    "recordType": {
                        "title": "Catalog type",
                        "enum": [
                            "anime",
                            "manga"
                        ],
                        "type": "string",
                        "description": "Collect anime or manga title records. Seasonal mode supports anime only.",
                        "default": "anime"
                    },
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Title or phrase to search, for example Frieren, One Piece, or cyberpunk."
                    },
                    "ids": {
                        "title": "MyAnimeList IDs",
                        "type": "array",
                        "description": "Exact numeric anime or manga IDs used in ID lookup mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "year": {
                        "title": "Season year",
                        "minimum": 1917,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Four-digit year for seasonal anime mode."
                    },
                    "season": {
                        "title": "Season",
                        "enum": [
                            "winter",
                            "spring",
                            "summer",
                            "fall"
                        ],
                        "type": "string",
                        "description": "Anime broadcast season for seasonal mode."
                    },
                    "maxItems": {
                        "title": "Maximum titles",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many unique title records.",
                        "default": 10
                    },
                    "sfw": {
                        "title": "Safe-for-work results only",
                        "type": "boolean",
                        "description": "Ask Jikan to omit adult search and discovery results.",
                        "default": true
                    },
                    "enrichCharacters": {
                        "title": "Add characters",
                        "type": "boolean",
                        "description": "Fetch characters and voice actors for every title. Adds one API request per title.",
                        "default": false
                    },
                    "maxCharacters": {
                        "title": "Characters per title",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum character entries retained when character enrichment is enabled.",
                        "default": 10
                    },
                    "enrichRecommendations": {
                        "title": "Add recommendations",
                        "type": "boolean",
                        "description": "Fetch related title recommendations for every result.",
                        "default": false
                    },
                    "maxRecommendations": {
                        "title": "Recommendations per title",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum recommendation entries retained per title.",
                        "default": 10
                    },
                    "enrichReviews": {
                        "title": "Add reviews",
                        "type": "boolean",
                        "description": "Fetch recent MyAnimeList reviews for every title.",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Reviews per title",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum review entries retained per title.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
