witanime APIwitanime.site ↗
Search the witanime.site catalogue, fetch title details, episode lists, and resolve playback/download sources via 4 structured endpoints.
What is the witanime API?
The witanime.site API exposes 4 endpoints covering the full content pipeline of the witanime.site catalogue: search for TV series, OVAs, specials, and movies by title; retrieve full detail records including genres, rating, and airing status; pull complete episode lists in one call; and resolve the publicly listed streaming player and file-download sources for any individual episode. The get_episode_sources endpoint is particularly useful for applications that need to surface available quality options (FHD, HD, SD, 4K) and dub/sub versions.
curl -X GET 'https://api.parse.bot/scraper/1a590837-b542-4349-9fe2-04e64948fafa/search_anime?query=bleach' \ -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 witanime-site-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.
"""Walkthrough: WitAnime SDK — search, drill into details, list episodes, resolve sources."""
from parse_apis.witanime_site_api import WitAnime, SourceKind, InputNotFound
client = WitAnime()
# Search the catalogue for a title and print the first few hits.
for hit in client.anime_summaries.search(query="bleach", limit=3):
print(hit.title, hit.type, hit.year)
# Drill down: take the first search result and fetch its full detail record.
summary = client.anime_summaries.search(query="bleach", limit=1).first()
if summary is not None:
anime = summary.details()
print(anime.title, anime.rating, anime.total_episodes)
print("Genres:", ", ".join(anime.genres))
# Walk the episode sub-resource and resolve playback sources for the first episode.
episode = anime.episodes.list(limit=1).first()
if episode is not None:
print(f"Episode {episode.number}: {episode.url}")
sources_info = episode.sources(source_kind=SourceKind.PLAYER)
for src in sources_info.sources:
print(f" {src.name} ({src.quality}) -> {src.external_url}")
# Point lookup by a known anime_id.
try:
detail = client.anime.get(anime_id="movie/bleach-movie-4-jigoku-hen")
print(detail.title, detail.year)
except InputNotFound:
print("Title not found")
print("exercised: anime_summaries.search / details / anime.get / episodes.list / episode.sources")
Searches the catalogue (TV series, specials, OVAs and movies) by title and returns one page of result cards. The site indexes romanised/English titles: Latin-script queries return matches, while the Arabic queries tried during the build returned zero results from the site itself. Results are paginated 24 per page; `page` selects the page (omitted = 1), `total_results` and `total_pages` come from the site's own result count, and `has_more` says whether a next page exists. A page past the last one yields an empty `results` array with null totals. Each card carries `anime_id` in the form `anime/<slug>` or `movie/<slug>`, which is the identifier accepted by get_anime_details and get_episodes. Cards do not show alternative titles or airing status; use get_anime_details for those. `type` is the site's badge (e.g. TV, Special, or `movie` for film cards). A search with no matches is a valid empty result.
| Param | Type | Description |
|---|---|---|
| page | integer | 1-based result page (24 cards per page). |
| queryrequired | string | Free-text title search term (romanised or English title). |
{
"type": "object",
"fields": {
"page": "integer page returned",
"query": "the search term as sent",
"results": "array of cards: anime_id (anime/<slug> or movie/<slug>), kind (anime|movie), url, title, poster, year (integer or null), type (site badge), rating (number or null)",
"has_more": "boolean, true when a later page exists",
"per_page": "integer cards per page (24)",
"total_pages": "integer number of pages, null when the requested page is past the end",
"total_results": "integer total matches reported by the site, null when the requested page is past the end"
},
"sample": {
"data": {
"page": 1,
"query": "bleach",
"results": [
{
"url": "https://witanime.site/anime/bleach-sennen-kessen-hen",
"kind": "anime",
"type": "TV",
"year": 2022,
"title": "BLEACH: Sennen Kessen-hen",
"poster": "https://images.witanime.site/posters/64339e337ab3b3281e331fdc7610fe6a.jpg",
"rating": 8.8,
"anime_id": "anime/bleach-sennen-kessen-hen"
},
{
"url": "https://witanime.site/movie/bleach-movie-4-jigoku-hen",
"kind": "movie",
"type": "movie",
"year": 2011,
"title": "Bleach Movie 4: Jigoku-hen",
"poster": "https://images.witanime.site/posters/2b9b5e39830434bb09d93b8bdc7edb52.jpg",
"rating": 7.8,
"anime_id": "movie/bleach-movie-4-jigoku-hen"
}
],
"has_more": false,
"per_page": 24,
"total_pages": 1,
"total_results": 10
},
"status": "success"
}
}About the witanime API
Search and Discovery
The search_anime endpoint accepts a query string (romanised or English title) and an optional 1-based page integer, returning up to 24 result cards per page. Each card includes anime_id (in the form anime/<slug> or movie/<slug>), kind, title, poster, year, and type. The total_results, total_pages, and has_more fields let you paginate across the full result set. Note that the site indexes content in romanised/Latin script — Arabic-script queries consistently return zero results from the source.
Title Details and Episode Lists
get_anime_details takes an anime_id and returns a complete record in one round trip: title, kind, type (TV, OVA, Special, or movie), year, rating, status (completed | ongoing | upcoming, or null for movies), season, genres (labels in Arabic), and poster. The full episode list is included in the same response — no secondary pagination call is required, even for long-running series.
If you only need episode data, get_episodes returns the same episode array (episode_id, number, title, url, thumbnail) plus total_episodes, without the title metadata overhead.
Source Resolution
get_episode_sources accepts an episode_id (format <anime-slug>/<episode-number> for series, movie/<slug> for films) and an optional source_kind filter (players, downloads, or both). Each resolved source entry includes name, kind, host, quality, version (sub|dub), and language. When resolution partially fails, the unresolved_sources array lists entries with their HTTP status and reason. The rate_limited boolean signals when at least one source should be re-requested.
The witanime API is a managed, monitored endpoint for witanime.site — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when witanime.site 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 witanime.site 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 tracker app that searches witanime.site by title and displays poster, year, and airing status from
get_anime_details. - Aggregate available streaming quality tiers (FHD, HD, SD, 4K) per episode using
get_episode_sourcesto surface resolution options to users. - Distinguish dubbed vs. subtitled episode sources using the
versionfield returned byget_episode_sources. - Enumerate a series' full episode list in one call via
get_episodesto build episode-by-episode navigation or progress tracking. - Filter catalogue results by
kind(anime vs. movie) andtype(TV, OVA, Special) fromsearch_animefor genre-specific browsing features. - Monitor ongoing series for new episodes by polling
get_episodeson titles wherestatusisongoing. - Compile download-host availability per episode by filtering
get_episode_sourcesresults withsource_kind=downloads.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does witanime.site have an official developer API?+
What does `get_episode_sources` return for a movie versus a series episode?+
episode_id takes the form <anime-slug>/<episode-number>; for a film it is movie/<slug>. In both cases the response returns the same sources array with name, kind, host, quality, version, and language fields, plus unresolved_sources for any entries that could not be resolved during that call.Does the API support searching in Arabic script?+
search_anime queries should use romanised or English title spellings.Does the API return episode-level metadata such as air dates or synopsis text?+
episodes array from get_episodes and get_anime_details includes number, title, url, and thumbnail, but not per-episode air dates or synopsis text. You can fork this API on Parse and revise it to add an endpoint that extracts those fields from individual episode pages.Are direct media stream URLs (e.g. .m3u8 or .mp4 files) returned by `get_episode_sources`?+
sources array returns destination hostnames and player/download page links as listed publicly on the site, not resolved media file URLs. Each entry points to a host page or embeddable player. You can fork this API on Parse and revise it to add deeper resolution of final stream manifests if your use case requires them.