# AniDB Scraper - Anime Database & Ratings (`lulzasaur/anidb-scraper`) Actor

Scrape anime data from AniDB. Search by title and get ratings, tags, genres, episode counts, staff, studios, related anime, and descriptions. Supports detail pages for full metadata.

- **URL**: https://apify.com/lulzasaur/anidb-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## AniDB Scraper - Anime Database & Ratings

Scrape anime data from [AniDB](https://anidb.net), one of the most comprehensive anime databases with 15,000+ anime entries, detailed metadata, community ratings, and rich tag taxonomies.

### What does AniDB Scraper do?

This scraper searches AniDB for anime titles and extracts structured data including:

- **Basic info**: Title, original Japanese title, AniDB ID, type (TV Series/Movie/OVA/etc.), episode count
- **Dates**: Air date, end date
- **Ratings**: Weighted rating, temporary (average) rating, review rating with vote counts
- **Detail data** (optional): Full description, tags, genres, staff/creators, studios, and related anime

### Rate Limiting

**Important**: AniDB aggressively rate-limits requests. This scraper enforces:

- Maximum 1 concurrent request
- 2.5-second delay between requests
- Realistic browser headers

This means scraping is slow by design. A search returning 20 results with details enabled will take approximately 1 minute. Plan accordingly.

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["Naruto"]` | Anime titles to search for |
| `maxListings` | integer | `50` | Maximum total anime to scrape |
| `scrapeDetails` | boolean | `false` | Visit detail pages for full metadata |
| `proxyConfiguration` | object | none | Proxy settings (recommended for large scrapes) |

### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Anime title (English/Romaji) |
| `titleOriginal` | string | Official Japanese title |
| `anidbId` | number | AniDB anime ID |
| `type` | string | TV Series, Movie, OVA, TV Special, Web, Music Video, Other |
| `episodeCount` | string | Number of episodes (or "TBC") |
| `startDate` | string | First air date |
| `endDate` | string | Last air date |
| `rating` | number | Weighted community rating (1-10) |
| `ratingCount` | number | Number of rating votes |
| `temporaryRating` | number | Average (temporary) rating |
| `temporaryRatingCount` | number | Number of average rating votes |
| `reviewRating` | number | Average review rating |
| `reviewRatingCount` | number | Number of reviews |
| `userCount` | number | Number of users who have this anime listed |
| `tags` | string | Comma-separated tags (from detail page) |
| `genres` | string | Comma-separated genres |
| `description` | string | Plot synopsis (detail page only) |
| `studios` | string | Animation studios (detail page only) |
| `creators` | array | Staff credits with roles (detail page only) |
| `relatedAnime` | array | Sequels, prequels, side stories (detail page only) |
| `searchQuery` | string | The search query that found this anime |
| `scrapedAt` | string | ISO timestamp of when the data was scraped |

### Example Output

#### Search only (scrapeDetails: false)

```json
{
    "title": "Naruto",
    "titleOriginal": null,
    "anidbId": 239,
    "type": "TV Series",
    "episodeCount": "220",
    "startDate": "03.10.2002",
    "endDate": "08.02.2007",
    "rating": 5.7,
    "ratingCount": 17468,
    "temporaryRating": 7.55,
    "temporaryRatingCount": 18436,
    "reviewRating": 7.4,
    "reviewRatingCount": 52,
    "userCount": 25441,
    "tags": null,
    "genres": null,
    "description": null,
    "studios": null,
    "creators": null,
    "relatedAnime": null,
    "url": "https://anidb.net/anime/239",
    "searchQuery": "Naruto",
    "scrapedAt": "2026-04-25T12:00:00.000Z"
}
```

#### With details (scrapeDetails: true)

```json
{
    "title": "Naruto",
    "titleOriginal": "NARUTO",
    "anidbId": 239,
    "type": "TV Series",
    "episodeCount": "220",
    "startDate": "2002-10-03",
    "endDate": "2007-02-08",
    "rating": 5.7,
    "ratingCount": 17468,
    "temporaryRating": 7.55,
    "temporaryRatingCount": 18436,
    "reviewRating": 7.4,
    "reviewRatingCount": 52,
    "userCount": 25441,
    "tags": "action, adventure, comedy, manga, martial arts, ninja, shounen, super power",
    "genres": "action, adventure, comedy, manga, martial arts, ninja, shounen, super power",
    "description": "Naruto closely follows the life of a boy who is feared and detested by the villagers...",
    "studios": "Studio Pierrot",
    "creators": [
        { "role": "Original Work", "names": ["Kishimoto Masashi"] },
        { "role": "Direction", "names": ["Date Hayato"] },
        { "role": "Series Composition", "names": ["Sumisawa Katsuyuki", "Takegami Junki"] },
        { "role": "Character Design", "names": ["Nishio Tetsuya", "Suzuki Hirofumi"] },
        { "role": "Music", "names": ["Masuda Toshio", "Musashi Project"] },
        { "role": "Animation Work", "names": ["Studio Pierrot"] }
    ],
    "relatedAnime": [
        {
            "title": "Naruto Shippuuden",
            "anidbId": 4880,
            "relation": "Sequel",
            "info": "TV Series, 2007-2017, 500 eps",
            "url": "https://anidb.net/anime/4880"
        }
    ],
    "url": "https://anidb.net/anime/239",
    "searchQuery": "Naruto",
    "scrapedAt": "2026-04-25T12:00:00.000Z"
}
```

### Use Cases

- **Anime research**: Build a database of anime metadata for analysis
- **Recommendation engines**: Use tags, genres, and related anime data
- **Community analytics**: Track rating distributions and popularity trends
- **Content aggregation**: Combine AniDB data with other anime databases
- **Watchlist management**: Export anime lists with full metadata

### Tips

1. **Start small**: Due to rate limits, test with 5-10 results first
2. **Use proxies**: For larger scrapes, enable proxy configuration to avoid IP bans
3. **Detail pages are expensive**: Each detail page requires an additional request with 2.5s delay
4. **Multiple queries**: You can search for multiple anime in one run, but the total is capped by maxListings

### Cost Estimation

This actor uses pay-per-event pricing:

- Each scraped anime item costs **$0.005**
- Example: 50 anime = $0.25
- Detail pages add time but not extra item cost (same anime, more data)

# Actor input Schema

## `searchQueries` (type: `array`):

Anime titles to search for (e.g. "Naruto", "Attack on Titan", "Steins;Gate"). Each query runs a separate search.

## `maxListings` (type: `integer`):

Maximum number of anime to scrape across all queries. Keep low due to AniDB rate limits (1 request per 2 seconds).

## `scrapeDetails` (type: `boolean`):

Visit each anime's detail page for full metadata (description, tags, genres, staff, studios, related anime). Much slower due to rate limits.

## `proxyConfiguration` (type: `object`):

Optional proxy configuration. Recommended for large scrapes to avoid IP bans.

## Actor input object example

```json
{
  "searchQueries": [
    "Naruto"
  ],
  "maxListings": 50,
  "scrapeDetails": false
}
```

# 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 = {
    "searchQueries": [
        "Naruto"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/anidb-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 = { "searchQueries": ["Naruto"] }

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/anidb-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 '{
  "searchQueries": [
    "Naruto"
  ]
}' |
apify call lulzasaur/anidb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/NPxEFb8NIlLKNJr7K/builds/CNBD7hxsku9sOGqI0/openapi.json