AniDB APIanidb.net ↗
Access AniDB anime metadata, episode details, character data, and seasonal charts via 7 REST endpoints. Search titles, filter by season, type, and year.
What is the AniDB API?
The AniDB API exposes 7 endpoints covering anime search, full series metadata, character lookups, episode details, and seasonal charts drawn from AniDB's community-maintained database. The get_anime_details endpoint alone returns episode lists with air dates and durations, tags, descriptions, and ratings for any series by numeric ID. Whether you need to search by keyword or filter by year, season, and airing status, the API gives structured JSON back for every request.
curl -X GET 'https://api.parse.bot/scraper/85433efe-2087-4e5a-bff1-1c78cbd5820a/search_anime?query=Naruto' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace anidb-net-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.anidb_anime_database_api import AniDB, Season, AiringStatus
anidb = AniDB()
# Search for anime by keyword
for anime in anidb.animes.search(query="Naruto"):
print(anime.title, anime.score)
# Get full details for a specific anime
details = anidb.animes.get(id="239")
print(details.title, details.description, details.rating)
# Browse episodes from the detail
for ep in details.episodes:
print(ep.title, ep.id)
# Filter anime by year, type, and airing status using enum
for item in anidb.animes.filter(year=2002, types="tvseries", airing_status=AiringStatus.FINISHED):
print(item.title, item.type, item.aired)
# Get seasonal chart with Season enum
for seasonal in anidb.animes.chart(year=2024, season=Season.SPRING):
print(seasonal.title, seasonal.type_info, seasonal.rating)
# Search characters
for char in anidb.characters.search(query="Goku"):
print(char.name, char.gender)
# Get character details and their anime appearances
character = anidb.characters.get(id="226")
print(character.name, character.description)
for appearance in character.related_anime:
print(appearance.title, appearance.role)
# Get episode details
episode = anidb.episodes.get(id="2732")
print(episode.title, episode.description)
Search for anime by title or keyword. Returns up to 25 results ranked by relevance score. Results include anime ID, title, and search score.
| Param | Type | Description |
|---|---|---|
| queryrequired | string | Search keyword or anime title (e.g. 'Naruto', 'Dragon Ball'). |
{
"type": "object",
"fields": {
"items": "array of anime search results with id, title, and score",
"total": "integer count of items returned"
},
"sample": {
"data": {
"items": [
{
"id": "17897",
"score": "16.008",
"title": "Naruto (2023)"
},
{
"id": "239",
"score": "7.670",
"title": "Naruto"
}
],
"total": 25
},
"status": "success"
}
}About the AniDB API
Anime Search and Metadata
The search_anime endpoint accepts a query string and returns up to 30 results, each with an id, title, and relevance score. When the query matches a single title exactly, the result may be a single-item array. To fetch full metadata, pass that id to get_anime_details, which returns the title, description, a tags array, and a complete episodes array — each episode object includes id, number, title, duration, and airdate. For multi-filter queries, advanced_search_anime accepts a query alongside year, season, types (comma-separated type names like tvseries), and an airing_status integer, returning up to 25 ranked results.
Characters and Episodes
search_character accepts a query and returns up to 30 matching characters with id, name, and gender. Passing a character id to get_character_details retrieves name, description, and a related_anime array where each entry includes the anime's id, title, and the character's role in that series. Individual episodes can be fetched directly with get_episode_details using a numeric episode id, returning title, description, air_date, and play_length fields without needing to go through the parent anime.
Seasonal Charts
The get_season_chart endpoint accepts an optional year integer and a season string (winter, spring, summer, or autumn). The response is an items array where each entry includes id, title, date, type_info, rating, and average. This makes it straightforward to build season-browsing features or compare ratings across a single cour. If neither parameter is provided, the endpoint returns data for the current or most recently populated season.
The AniDB API is a managed, monitored endpoint for anidb.net — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when anidb.net changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official anidb.net API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build an anime recommendation engine using tags and ratings from
get_anime_details. - Populate a seasonal airing calendar using
get_season_chartwith year and season filters. - Generate character profile pages using
name,description, andrelated_animefromget_character_details. - Track episode air dates and durations for a watchlist app using the
episodesarray inget_anime_details. - Filter anime by type and airing status for a discovery tool using
advanced_search_anime. - Cross-reference a character's appearances across multiple series using the
related_animefield. - Fetch standalone episode synopses for a trivia or quiz application via
get_episode_details.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does AniDB have an official developer API?+
What does `get_anime_details` return, and how does the episode data look?+
id, title, description, tags (an array of tag name strings), and episodes. Each object in the episodes array includes id, number, title, duration, and airdate. Tags may be an empty array if the anime has none recorded on AniDB.Does `search_anime` support pagination or return more than 30 results?+
search_anime returns up to 30 results per call and does not expose a pagination parameter. The total field reflects the count of items actually returned in that response, not the full database count. You can fork the API on Parse and revise it to add offset or page-based pagination if your use case requires deeper result sets.Is staff, voice actor, or studio data available through this API?+
How does the `airing_status` filter in `advanced_search_anime` work?+
airing_status parameter accepts a numeric code; for example, 2 corresponds to finished airing. The accepted integer values map to AniDB's internal status taxonomy, so you should test values against known series to confirm which codes are active. The endpoint returns up to 25 results regardless of how many filters are applied.