# TV Shows, Anime & Manga MCP Server (`mrbridge/tv-anime-mcp`) Actor

TV shows, anime and manga MCP server for Claude, ChatGPT and Cursor: ask when the next episode airs, browse episode guides with their casts, check TV or streaming schedules, see anime seasons with airing times, and search manga. TV data from TVmaze (CC BY-SA 4.0), anime and manga from AniList.

- **URL**: https://apify.com/mrbridge/tv-anime-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, Videos
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 📺 TV Shows, Anime & Manga MCP Server

Give Claude, ChatGPT, Cursor, VS Code or any MCP client a TV guide plus anime and manga lookups it can query. This MCP server reads TVmaze and AniList through 22 read-only tools. TVmaze covers TV and web series: show cards, next episodes, episode guides, casts with voice roles and crew, people, plus daily TV or streaming schedules by country. AniList covers anime (studio, score, where to stream, seasons, airing times) as well as manga, manhwa or light novels (chapters, volumes, adaptations). ChatGPT gets its `search` and `fetch` pair over both.

Ask "what anime airs in Japan today, and when is the next episode of the one I'm watching?" and your assistant calls `media_tv_schedule`, then `media_get_next_episode`. You get today's anime slots with their channel, then the air date and time of the next episode. TV data from TVmaze, licensed under CC BY-SA 4.0: credit TVmaze and share alike when you reuse it. Anime and manga data from AniList, under the AniList API Terms of Use.

### Quick start

1. Copy your Apify API token from [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge).
2. Point your MCP client at `https://mrbridge--tv-anime-mcp.apify.actor/mcp` with that token, as a Bearer header or as `?token=` in claude.ai and ChatGPT ([Connect](#connect) has every recipe).
3. Ask in plain language.

### What this server exposes

This server wraps two public APIs in 22 read-only tools. From TVmaze (https://www.tvmaze.com/api) come 14 `media_` tools for shows, episodes, seasons, cast, crew, alternate titles, people, their credits and the daily TV and streaming schedules. From AniList (https://anilist.co) come 6 `media_` tools. Four cover anime: search by title or genre, one anime with its studio, score, streaming links, sequels and source manga, the anime of a season, and the episodes airing in a time window. Two cover manga, manhwa and light novels: search by title, genre, format or country, and one manga with its chapters, volumes, authors, reading links and anime adaptations. The `search` and `fetch` pair that ChatGPT deep research expects reads both sources, and each id it returns names its source. It covers TV and web series from many countries, anime series and films, and manga, but not live-action films or adult titles. It needs no credentials and no third-party key: you connect with your Apify token, and each successful call is billed as one event. On top of the events you pay the platform usage of your own Standby run, billed to your Apify account: the memory set for the run while the server is up, idle time included, until it stops at its idle timeout (see Pricing). TVmaze data is licensed CC BY-SA 4.0 and AniList data comes under the AniList API Terms of Use. Every answer carries the credit, the link to each item's page on the source site and the list of changes this server makes.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `media_search_shows` | Search TV shows | `tool-read` |
| `media_get_show` | Get a TV show | `tool-read` |
| `media_get_next_episode` | Get the next episode of a show | `tool-read` |
| `media_list_seasons` | List the seasons of a show | `tool-read` |
| `media_get_alternate_titles` | Get the alternate titles of a show | `tool-read` |
| `media_list_episodes` | List the episodes of a show | `tool-read` |
| `media_get_episode` | Get one episode | `tool-read` |
| `media_get_cast` | Get the main cast of a show | `tool-action` |
| `media_get_crew` | Get the crew of a show | `tool-read` |
| `media_tv_schedule` | TV schedule of a country | `tool-action` |
| `media_streaming_schedule` | Streaming release schedule | `tool-action` |
| `media_search_people` | Search people in TV | `tool-read` |
| `media_get_person` | Get a person | `tool-read` |
| `media_list_person_credits` | List the credits of a person | `tool-read` |
| `media_search_anime` | Search anime | `tool-read` |
| `media_get_anime` | Get an anime | `tool-action` |
| `media_list_season_anime` | Anime of a season | `tool-read` |
| `media_anime_airing_schedule` | Anime airing schedule | `tool-read` |
| `media_search_manga` | Search manga | `tool-read` |
| `media_get_manga` | Get a manga | `tool-action` |
| `search` | Search | `tool-read` |
| `fetch` | Fetch | `tool-read` |

#### `media_search_shows`: Search TV shows

Use this when you need to find a TV series, web series or anime series by its title, and get its TVmaze id, premiere year, network or streaming service, status and rating to tell same-named shows apart. Do not use for films (TVmaze lists series only), for people (media_search_people) or when you already have the show id (media_get_show). Parameters: `query` (title, e.g. "severance"), `limit` (1 to 10, TVmaze returns at most 10 matches), `offset`, `response_format` ("detailed" adds runtime, schedule, identifiers, poster URLs and a summary excerpt).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"severance"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, shows[], pagination, next_steps[], attribution }`. Upstream: TVmaze. Cache: daily (1 day). Read-only.

#### `media_get_show`: Get a TV show

Use this when you need the card of one TV or anime series: type, language, genres, status, premiere and end dates, network or streaming service, rating, IMDb id, a summary excerpt (at most 300 characters), plus its next and previous episode. Do not use for the full episode list (media_list_episodes), the cast (media_get_cast) or to compare several candidates (media_search_shows). Give exactly one of: `show_id` (TVmaze id, e.g. 82), `imdb_id` (e.g. "tt0944947" or an IMDb URL), `thetvdb_id` (e.g. 121361) or `show_name` (best single match, e.g. "Severance"). `response_format` "detailed" adds runtime, weekly schedule with time zone, official site, poster URLs, other ids and the last update time.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `show_id` | integer | no | `82` |
| `imdb_id` | string | no | `"tt0944947"` |
| `thetvdb_id` | integer | no | `121361` |
| `show_name` | string | no | `"Severance"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ show, next_episode, previous_episode, match_note, next_steps[], attribution }`. Upstream: TVmaze. Cache: hourly (1 hour). Read-only.

#### `media_get_next_episode`: Get the next episode of a show

Use this when someone asks when the next episode of a TV or anime series airs, whether a show is still running, or what the latest episode was. Do not use for the whole episode list (media_list_episodes) or for what airs on a given day across channels (media_tv_schedule, media_streaming_schedule). Give exactly one of `show_id` (TVmaze id, e.g. 82), `imdb_id` (e.g. "tt0944947"), `thetvdb_id` (e.g. 121361) or `show_name` (best single match, e.g. "Severance"). `response_format` "detailed" adds episode summaries and images. Returns the next and previous episode with air date, local air time and UTC timestamp, the hours until the next one, and a one-line status note. Streaming releases often have no air time: the timestamp and the hours are then null and the date stands alone.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `show_id` | integer | no | `82` |
| `imdb_id` | string | no | `"tt0944947"` |
| `thetvdb_id` | integer | no | `121361` |
| `show_name` | string | no | `"Severance"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ show, next_episode, previous_episode, hours_until_next, status_note, match_note, attribution }`. Upstream: TVmaze. Cache: hourly (1 hour). Read-only.

#### `media_list_seasons`: List the seasons of a show

Use this when you need how many seasons a TV or anime series has, how many episodes each season has, and when each season premiered and ended. Do not use for the episodes themselves (media_list_episodes) or for the show card (media_get_show). Parameters: `show_id` (TVmaze id, e.g. 82), `limit` (1 to 100, default 50, at most 30 in detailed mode), `offset`, `response_format` ("detailed" adds poster URLs and summary excerpts).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `show_id` | integer | yes | `82` |
| `limit` | integer | no | `50` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ show_id, seasons[], pagination, next_steps[], attribution }`. Upstream: TVmaze. Cache: hourly (1 hour). Read-only.

#### `media_get_alternate_titles`: Get the alternate titles of a show

Use this when you need what a TV or anime series is called in another country or language, or its original title (for anime, the Japanese title in Latin letters). Do not use for searching a show by one of these titles (media_search_shows already matches them). Parameters: `show_id` (TVmaze id, e.g. 82), `country` (ISO 3166-1 alpha-2 code such as "FR" or "JP", UK is read as GB, or "original" for the title in the country of origin), `limit` (1 to 100, default 50), `offset`, `response_format`. A title whose country is null is the title in the show's original country.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `show_id` | integer | yes | `82` |
| `country` | string | no | `"FR"` |
| `limit` | integer | no | `50` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ show_id, tvmaze_url, country, titles[], pagination, attribution }`. Upstream: TVmaze. Cache: daily (1 day). Read-only.

#### `media_list_episodes`: List the episodes of a show

Use this when you need the episode guide of a TV or anime series: season and episode numbers, titles, air dates and times, runtimes and ratings, for the whole show, one season, or one air date. Do not use for one episode in depth (media_get_episode), the next episode only (media_get_next_episode) or what airs on a day across channels (media_tv_schedule). Parameters: `show_id` (TVmaze id, e.g. 82), `season` (season number, e.g. 2, daily shows number seasons by year), `aired_on` (YYYY-MM-DD, episodes aired that day, not combinable with season), `include_specials` (true adds specials, default false), `limit` (1 to 50, default 25, at most 20 in detailed mode), `offset`, `response_format` ("detailed" adds summary excerpts and image URLs).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `show_id` | integer | yes | `82` |
| `season` | integer | no | `1` |
| `aired_on` | string | no | `"2026-10-05"` |
| `include_specials` | boolean | no | `false` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ show_id, show_name, season, aired_on, episodes[], pagination, next_steps[], attribution }`. Upstream: TVmaze. Cache: hourly (1 hour). Read-only.

#### `media_get_episode`: Get one episode

Use this when you need one episode of a TV or anime series: title, air date and time, runtime, rating, a summary excerpt, and optionally its guest cast. Do not use for a list of episodes (media_list_episodes) or the main cast of the show (media_get_cast). Give `episode_id` (TVmaze episode id, e.g. 1), or `show_id` with `season` and `number` (e.g. show 82, season 1, number 3). `include_guest_cast` (true adds the guest stars, one more call, default false), `response_format` (concise by default, "detailed" adds image URLs and guest images).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `episode_id` | integer | no | `1` |
| `show_id` | integer | no | `82` |
| `season` | integer | no | `1` |
| `number` | integer | no | `3` |
| `include_guest_cast` | boolean | no | `true` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ episode, guest_cast, guest_cast_total, guest_cast_notice, next_steps[], attribution }`. Upstream: TVmaze. Cache: hourly (1 hour). Read-only.

#### `media_get_cast`: Get the main cast of a show

Use this when you need who plays or voices whom in a TV or anime series: actor or voice actor names next to their characters, ordered by importance, with voice roles flagged. Do not use for guest stars of one episode (media_get_episode with include_guest_cast), for the crew (media_get_crew) or for an actor's other roles (media_list_person_credits). Parameters: `show_id` (TVmaze id, e.g. 82), `voice_only` (true keeps voice roles, useful for anime, default false), `limit` (1 to 50, default 20), `offset`, `response_format` ("detailed" adds countries and image URLs).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `show_id` | integer | yes | `82` |
| `voice_only` | boolean | no | `false` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ show_id, cast[], pagination, next_steps[], attribution }`. Upstream: TVmaze. Cache: daily (1 day). Read-only.

#### `media_get_crew`: Get the crew of a show

Use this when you need who created, wrote, directed, produced or composed the music of a TV or anime series. Do not use for the actors (media_get_cast) or for one person's work across shows (media_list_person_credits). Parameters: `show_id` (TVmaze id, e.g. 82), `crew_type` (part of the role, e.g. "Creator", "Director", "Executive Producer", "Music"), `limit` (1 to 50, default 20), `offset`, `response_format` ("detailed" adds countries and image URLs).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `show_id` | integer | yes | `82` |
| `crew_type` | string | no | `"Creator"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ show_id, crew[], pagination, attribution }`. Upstream: TVmaze. Cache: daily (1 day). Read-only.

#### `media_tv_schedule`: TV schedule of a country

Use this when you need what airs on broadcast and cable TV in one country on one day, for example tonight in the UK, or the anime airing in Japan today (country "JP", genre "Anime"). Do not use for streaming releases on Netflix, Crunchyroll and other web channels (media_streaming_schedule) or for the next episode of one show (media_get_next_episode). Parameters: `country` (ISO 3166-1 alpha-2, default "US", "UK" is read as "GB"), `date` (YYYY-MM-DD, default today on TVmaze), `network` (part of the channel name, e.g. "BBC"), `genre`, `show_type`, `language` (filters, e.g. "Anime", "Animation", "Japanese"), `limit` (1 to 50, default 25, at most 20 in detailed mode), `offset`, `response_format` ("detailed" adds summary excerpts and image URLs). Rows are in airing order with local air time and UTC timestamp.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `country` | string | no | `"GB"` |
| `date` | string | no | `"2026-10-05"` |
| `network` | string | no | `"BBC"` |
| `genre` | string | no | `"Anime"` |
| `show_type` | string | no | `"Animation"` |
| `language` | string | no | `"Japanese"` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ date, country, filters, total_before_filters, episodes[], pagination, next_steps[], attribution }`. Upstream: TVmaze. Cache: hourly (1 hour). Read-only.

#### `media_streaming_schedule`: Streaming release schedule

Use this when you need which episodes are released on streaming and web channels on one day, for example new episodes on Netflix, Prime Video, Disney+ or Crunchyroll today. Do not use for broadcast and cable TV (media_tv_schedule) or for the next episode of one show (media_get_next_episode). Parameters: `date` (YYYY-MM-DD, default today on TVmaze), `country` (ISO code: only the local web channels of that country) or `global_only` (true: only worldwide services such as Netflix), leave both out for all, `web_channel` (part of the service name, e.g. "Crunchyroll"), `genre`, `show_type`, `language` (filters), `limit` (1 to 50, default 25, at most 20 in detailed mode), `offset`, `response_format`.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `date` | string | no | `"2026-10-05"` |
| `country` | string | no | `"GB"` |
| `global_only` | boolean | no | `false` |
| `web_channel` | string | no | `"Crunchyroll"` |
| `genre` | string | no | `"Anime"` |
| `show_type` | string | no | `"Animation"` |
| `language` | string | no | `"Japanese"` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ date, country, filters, total_before_filters, episodes[], pagination, next_steps[], attribution, scope }`. Upstream: TVmaze. Cache: hourly (1 hour). Read-only.

#### `media_search_people`: Search people in TV

Use this when you need to find an actor, voice actor, presenter, director or writer of TV and anime series by name, and get the TVmaze person id. Do not use for shows (media_search_shows) or when you already have the person id (media_get_person). Parameters: `query` (name, e.g. "Bryan Cranston"), `limit` (1 to 10, TVmaze returns at most 10 matches), `offset`, `response_format` ("detailed" adds birth and death dates, gender and image URLs).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"Bryan Cranston"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, people[], pagination, next_steps[], attribution }`. Upstream: TVmaze. Cache: daily (1 day). Read-only.

#### `media_get_person`: Get a person

Use this when you need the TVmaze profile of one person in TV: country, birth and death dates and gender as TVmaze publishes them, and the TVmaze page. Do not use for the shows of that person (media_list_person_credits) or to find a person by name (media_search_people). Parameters: `person_id` (TVmaze person id, e.g. 9001), `response_format` ("detailed" adds image URLs and the last update time).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `person_id` | integer | yes | `9001` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ person, next_steps[], attribution }`. Upstream: TVmaze. Cache: daily (1 day). Read-only.

#### `media_list_person_credits`: List the credits of a person

Use this when you need the TV and anime series a person appeared in, voiced, presented or worked on: show names with the character played, the crew role, or the guest episodes, most recent first. Do not use for the cast of one show (media_get_cast) or the person profile (media_get_person). Parameters: `person_id` (TVmaze id, e.g. 9001), `credit_type` ("cast" main roles, the default, "crew" for roles such as creator or director, "guest_cast" for guest appearances in single episodes), `limit` (1 to 50, default 25, at most 20 in detailed mode), `offset`, `response_format` ("detailed" adds show type, status, channel and character page).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `person_id` | integer | yes | `9001` |
| `credit_type` | "cast" or "crew" or "guest_cast" | no | `"cast"` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ person_id, credit_type, credits[], pagination, next_steps[], attribution }`. Upstream: TVmaze. Cache: daily (1 day). Read-only.

#### `media_search_anime`: Search anime

Use this when you need to find an anime (series, film, OVA or web release) by its English, romaji or Japanese title, or to list anime by genre, start year, format or status, ranked by relevance, popularity, score or trending, with its AniList id, season, episodes and average score. Do not use for manga (media_search_manga), for live-action or Western TV series (media_search_shows) or when you already have the AniList id (media_get_anime). Parameters: `query` (title, e.g. "frieren"), `genre` (AniList genre such as "Romance", "Mecha" or "Slice of Life"), `year` (start year, e.g. 2023), `format` (tv, tv_short, movie, special, ova, ona, music), `status` (finished, releasing, not_yet_released, cancelled), `sort` (relevance, the default with a query and only with one, popularity, the default without, score, trending), `limit` (1 to 25, default 10, at most 10 in detailed mode), `offset`, `response_format` ("detailed" adds studios, source, popularity, MyAnimeList id and a description excerpt). Reads at most 50 matches per question. Adult entries are never returned.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | no | `"frieren"` |
| `genre` | string | no | `"Romance"` |
| `year` | integer | no | `2023` |
| `format` | "tv" or "tv_short" or "movie" or "special" or "ova" or "ona" or "music" | no | `"tv"` |
| `status` | "finished" or "releasing" or "not_yet_released" or "cancelled" | no | `"releasing"` |
| `sort` | "relevance" or "popularity" or "score" or "trending" | no | `"popularity"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, filters, anime[], pagination, more_on_anilist, coverage_note, next_steps[], attribution }`. Upstream: AniList. Cache: live (30 seconds). Read-only.

#### `media_get_anime`: Get an anime

Use this when you need the card of one anime from AniList: titles, format, status, episodes and their length, season, dates, main studio, average score, genres, top tags, a description excerpt (at most 300 characters), where to stream it, related anime such as sequels, prequels and side stories, related manga such as the source manga, and the next episode with the hours until it airs. Do not use for comparing candidates (media_search_anime), for the anime of a season (media_list_season_anime) or for an episode-by-episode guide (media_list_episodes covers series listed on TVmaze). Give exactly one of `anime_id` (AniList id, e.g. 1 for Cowboy Bebop, from media_search_anime or an AniList URL), `mal_id` (MyAnimeList id, e.g. 1) or `anime_name` (AniList's first search match, e.g. "Cowboy Bebop"). `response_format` "detailed" adds alternative titles, the English title, mean score, popularity, source, country and MyAnimeList id.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `anime_id` | integer | no | `1` |
| `mal_id` | integer | no | `1` |
| `anime_name` | string | no | `"Cowboy Bebop"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ anime, next_episode, tags[], streaming_links[], related_anime[], related_manga[], alternative_titles[], match_note, next_steps[], attribution }`. Upstream: AniList. Cache: live (30 seconds). Read-only.

#### `media_list_season_anime`: Anime of a season

Use this when you need the anime of one season, for example what airs this season or the most popular or best rated anime of fall 2023, with studio, episodes, average score and the next episode of each airing series. Do not use for a title search (media_search_anime) or for what airs on a given day (media_anime_airing_schedule). Parameters: `season` (winter, spring, summer or fall) and `year` (e.g. 2023). Without both: the current season. A season alone: its nearest occurrence (winter asked in December is the coming one). A year needs a season. `format` (tv, tv_short, movie, special, ova, ona, music), `sort` (popularity by default, score, trending, start_date), `limit` (1 to 25, default 20, at most 10 in detailed mode), `offset`, `response_format` ("detailed" adds source, popularity, MyAnimeList id and a description excerpt). Reads at most 50 anime per season and says when AniList has more. Adult entries are never returned.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `season` | "winter" or "spring" or "summer" or "fall" | no | `"fall"` |
| `year` | integer | no | `2023` |
| `format` | "tv" or "tv_short" or "movie" or "special" or "ova" or "ona" or "music" | no | `"tv"` |
| `sort` | "popularity" or "score" or "trending" or "start_date" | no | `"popularity"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ season, year, format, sort, anime[], pagination, more_on_anilist, coverage_note, next_steps[], attribution }`. Upstream: AniList. Cache: live (30 seconds). Read-only.

#### `media_anime_airing_schedule`: Anime airing schedule

Use this when you need which anime episodes air in a time window, for example today in Japan (utc_offset "+09:00") or over the next few days, with episode number, air time in UTC and at the offset, hours until it airs (negative once aired) and whether it has aired. Do not use for TV or streaming listings of other series (media_tv_schedule, media_streaming_schedule) or for the next episode of one anime (media_get_anime). Parameters: `date` (YYYY-MM-DD, default today at utc_offset), `days` (1 to 7, default 1), `utc_offset` (e.g. "+09:00", default "+00:00"), `limit` (1 to 25, default 25, at most 10 in detailed mode), `offset`, `response_format` ("detailed" adds native and English titles, episode length and genres). AniList only aims to keep future airing times accurate. Reads at most 50 episodes per window: when AniList holds more, `covered_until` says where the rows stop and next_steps gives the call for the rest. Adult entries are never returned.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `date` | string | no | `"2026-10-07"` |
| `days` | integer | no | `1` |
| `utc_offset` | string | no | `"+09:00"` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ date, days, utc_offset, window_start, window_end, covered_until, episodes[], pagination, more_on_anilist, coverage_note, next_steps[], attribution }`. Upstream: AniList. Cache: live (30 seconds). Read-only.

#### `media_search_manga`: Search manga

Use this when you need to find a manga, light novel or one-shot (Japanese manga, Korean manhwa, Chinese manhua) by its English, romaji or native title, or to list them by genre, start year, format, status or country, ranked by relevance, popularity, score or trending, with its AniList id, chapters, volumes and average score. Do not use for anime (media_search_anime), for TV series (media_search_shows) or when you already have the AniList id (media_get_manga). Parameters: `query` (title, e.g. "berserk"), `genre` (AniList genre such as "Fantasy", "Romance" or "Slice of Life"), `year` (start year, e.g. 2020), `format` (manga, novel, one_shot), `status` (finished, releasing, not_yet_released, cancelled), `country` (JP, KR, CN, TW), `sort` (relevance, the default with a query and only with one, popularity, the default without, score, trending), `limit` (1 to 25, default 10, at most 10 in detailed mode), `offset`, `response_format` ("detailed" adds source, popularity, MyAnimeList id and a description excerpt). Reads at most 50 matches per question. Adult entries are never returned.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | no | `"berserk"` |
| `genre` | string | no | `"Fantasy"` |
| `year` | integer | no | `2020` |
| `format` | "manga" or "novel" or "one_shot" | no | `"manga"` |
| `status` | "finished" or "releasing" or "not_yet_released" or "cancelled" | no | `"releasing"` |
| `country` | "JP" or "KR" or "CN" or "TW" | no | `"KR"` |
| `sort` | "relevance" or "popularity" or "score" or "trending" | no | `"popularity"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, filters, manga[], pagination, more_on_anilist, coverage_note, next_steps[], attribution }`. Upstream: AniList. Cache: live (30 seconds). Read-only.

#### `media_get_manga`: Get a manga

Use this when you need the card of one manga, light novel or one-shot from AniList: titles, format, status (HIATUS for a paused series), chapters and volumes, dates, country, average score, genres, top tags, a description excerpt (at most 300 characters), credited staff such as the author and the artist, official reading links, related manga such as sequels, spin-offs and light novels, and related anime such as adaptations. Do not use for comparing candidates (media_search_manga) or for an anime (media_get_anime). Give exactly one of `manga_id` (AniList id, e.g. 30002 for Berserk, from media_search_manga or an AniList URL), `mal_id` (MyAnimeList manga id, e.g. 2) or `manga_name` (AniList's first search match, e.g. "Berserk"). `response_format` "detailed" adds alternative titles, the English title, mean score, popularity, source and MyAnimeList id.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `manga_id` | integer | no | `30002` |
| `mal_id` | integer | no | `2` |
| `manga_name` | string | no | `"Berserk"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ manga, staff[], tags[], reading_links[], related_manga[], related_anime[], alternative_titles[], match_note, next_steps[], attribution }`. Upstream: AniList. Cache: live (30 seconds). Read-only.

#### `search`: Search

Use this when ChatGPT needs to find TV series, anime series and people of television (actors, voice actors, creators) on TVmaze, and anime (series and films) and manga (light novels and manhwa included) on AniList, by title or name. Do not use for live-action films or books, which these sources do not cover. Parameter `query` (string), e.g. "frieren". Returns up to 8 shows, up to 4 anime and 4 manga, then up to 4 people, with ids that name their source such as "tvmaze:show-82", "tvmaze:person-1", "anilist:anime-1" or "anilist:manga-30002".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"frieren"` |

Returns `{ results[], notices[] }`. Upstream: TVmaze, AniList. Cache: daily (1 day). Read-only.

#### `fetch`: Fetch

Use this when ChatGPT needs the full card of one result of search, as text: status, dates, channel, genres, schedule, rating, next and previous episode and main cast for a show, profile and main roles for a person, format, episodes or chapters and volumes, studio or staff, score, where to watch or read and related titles for an anime or a manga. Do not use for ids that did not come from search or from a TVmaze or AniList page URL. Parameter `id`, e.g. "tvmaze:show-82", "tvmaze:person-1", "anilist:anime-1", "anilist:manga-30002" or "https://www.tvmaze.com/shows/82/game-of-thrones".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `id` | string | yes | `"tvmaze:show-82"` |

Returns `{ id, title, text, url, metadata, notices[] }`. Upstream: TVmaze, AniList. Cache: daily (1 day). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--tv-anime-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Claude Code

```bash
claude mcp add --transport http tv-anime "https://mrbridge--tv-anime-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "tv-anime": {
      "type": "http",
      "url": "https://mrbridge--tv-anime-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--tv-anime-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add TV Shows, Anime & Manga MCP Server to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=TV%20Shows%2C%20Anime%20%26%20Manga%20MCP%20Server\&connectorUrl=https%3A%2F%2Fmrbridge--tv-anime-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--tv-anime-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "tv_anime",
  "server_url": "https://mrbridge--tv-anime-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--tv-anime-mcp.apify.actor/mcp",
      "name": "tv-anime",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "tv-anime"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/tv-anime-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use this server

- **Next episode in one call.** Air date and time, plus whether the show is running or ended, from a TVmaze id, an IMDb id, a TheTVDB id or a plain title.
- **Schedules by country and service.** Tonight's broadcast and cable listings for a country, and the day's streaming releases on services such as Netflix or Crunchyroll, filtered by genre, type or language.
- **Anime cards that answer the usual questions.** Main studio, average score, top tags without spoilers, where to stream, the watch order through sequels and prequels, and the source manga.
- **Manga, manhwa, light novels.** Search by title, genre, format or country of origin, then get chapter and volume counts, the credited author and artist, official reading links and the anime adaptations.
- **People and credits.** Find an actor, voice actor or creator and list what they appeared in, with roles and guest spots, newest first.
- **Citations built in.** Each item links to its TVmaze or AniList page, and the ChatGPT pair cites those pages in deep research.
- **No key to manage.** Connect with your Apify token. You pay per successful call, plus the platform usage of your own server run.

### Pricing (Pay-per-Event)

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |
| `tool-action` | each successful call of a detailed or computed tool | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **Attribution.** Each answer carries an `attribution` block: the source (TVmaze or AniList), the licence or terms (CC BY-SA 4.0 for TVmaze, the AniList API Terms of Use for AniList), the terms page, and notices with the credit line, the changes made and the non-affiliation line. Each show, episode, season, person and character comes with its TVmaze page URL, and each anime, manga and staff member with its AniList page URL (`anilist_url`). Keep both with the data when you pass it on.
- **Anime and manga from AniList.** The six AniList tools read one AniList page of at most 50 entries per question and page through it in memory. When AniList holds more, `more_on_anilist` and `coverage_note` say so: narrow the question (a genre, a format, a country, fewer days) rather than looking for a next page. For airing windows, `covered_until` gives the air time of the last row, and `next_steps` holds the call that lists the rest. Genres must be AniList genres (Action, Romance, Slice of Life and the like): other words are refused before any call. Descriptions are excerpts of at most 300 characters, with spoiler blocks and spoiler tags removed, and no cover image is returned. Adult entries never appear: every query asks AniList to leave them out, and every entry is checked again, which also leaves out any entry of the Hentai genre. Ecchi titles are not adult on AniList, so they do appear. Past airing times may be off, since AniList only aims to keep future ones accurate.
- **Manga.** Manga, manhwa and manhua are told apart by `country` (JP, KR, CN or TW), as AniList has no genre for them. `status` is AniList's newer status, so a paused series reads `HIATUS`. `chapters` and `volumes` are null while a series is still running. Staff are names and roles in AniList's order, at most 10, with no other personal detail. Reading links are the official sites AniList lists, never chapter text. There is no list, tracker or reading progress feature.
- **ChatGPT pair.** `search` asks TVmaze for shows and people and AniList for anime and manga, and returns at most 8 shows, 4 anime, 4 manga and 4 people. Ids name their source (`tvmaze:show-82`, `tvmaze:person-1`, `anilist:anime-1`, `anilist:manga-30002`). `fetch` also accepts TVmaze and AniList page URLs, and the short `show-82` and `person-1` forms. When one source fails or is busy, the answer keeps the results of the other and says which part failed.
- **Summaries.** Summaries are short excerpts of at most 300 characters, as plain text, with `summary_truncated` when cut. Lists show them in detailed mode only. `media_get_show` and `media_get_episode` show them in both modes. The full text stays on the TVmaze page of the item.
- **Images.** Poster and photo fields are links to the TVmaze image server, given in detailed mode. This server never downloads or hosts an image. Posters and photos can belong to networks and studios, so check the rights before you reuse one.
- **Coverage.** TVmaze lists TV and web series, anime series included (type "Animation", often with the genre "Anime"). It has no films and no manga. AniList adds anime films, OVAs, studios, scores and seasons, plus manga, manhwa, manhua, light novels and one-shots. Schedules cover what TVmaze knows for a country and a day. Global streaming services such as Netflix only appear in `media_streaming_schedule`. The TVmaze and AniList ids are separate, and so are AniList's anime and manga ids: a `show_id` is not an `anime_id`, and an `anime_id` is not a `manga_id`.
- **Names.** `show_name` in `media_get_show` and `media_get_next_episode` takes TVmaze's single best match, which can be the wrong show when several share a title. The answer says so in `match_note`. Use `media_search_shows` and `show_id` when in doubt.
- **Rate limits.** TVmaze allows at least 20 calls every 10 seconds per IP address. This server keeps to 10 per 10 seconds per instance, makes its calls one at a time, and waits and retries after a rate-limit answer. AniList allows 30 calls a minute for now. This server keeps to one AniList call every 4 seconds per instance, and a ChatGPT `search` makes one of them. After a rate-limit answer from AniList it sends nothing to AniList until the one-minute timeout AniList imposes is over, and the anime and manga tools say how many seconds are left. A busy period can still answer `UPSTREAM_RATE_LIMITED`, with the delay the source asks for when it gives one. Wait a minute and call again.
- **Freshness.** TVmaze caches its own answers for an hour. This server caches show records, episode lists and dated schedules for an hour, today's schedule for five minutes, and searches, casts, crews and people for a day. AniList answers stay in memory for 30 seconds and are never written to storage, so the same anime or manga question asked a minute later goes back to AniList. The ChatGPT pair keeps the same rules for each source: up to a day for TVmaze, 30 seconds for AniList. The hours until an episode airs are worked out when the answer is built. A source that is down can be answered from an older copy, marked `stale` in the `cache` block (at most five minutes old for AniList).
- **Sizes.** Lists are paged with `limit` and `offset`. Detailed mode returns at most 20 rows per page (30 for seasons, 10 for the anime and manga lists) and says so in the paging notice.

### Data terms

TVmaze licenses its API data under [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/) ([TVmaze licensing](https://www.tvmaze.com/api#licensing)). What the TVmaze tools return is an adaptation of that data, shared under the same licence. By using them you agree to:

- credit TVmaze as the source and link to the TVmaze page of each item (the `tvmaze_url` fields) wherever you show or publish the data,
- share what you build from the data under CC BY-SA 4.0 as well, as the ShareAlike clause requires,
- leave out any wording or logo that suggests TVmaze endorses you or this server,
- check the rights of posters and photos before reusing them, since TVmaze links to images that networks and studios provide.

AniList data reaches you under the [AniList API Terms of Use](https://docs.anilist.co/guide/terms-of-use). They give you no licence to pass the data on, and they rule out some uses. By using the anime and manga tools, or the AniList results of `search` and `fetch`, you agree:

- not to use the answers as a backup or a store of AniList data, and not to collect AniList data in bulk through this server,
- not to use them in an anime or manga list or tracker, or in any other service that competes with AniList,
- to link to the AniList page of each anime, manga or staff member (the `anilist_url` fields) wherever you show the data,
- not to call your own product "AniList", and to add "UNOFFICIAL" or "for AniList" to its name if the name contains AniList.

This server is not affiliated with or endorsed by TVmaze or AniList. AniList can change or close its API at any time, and this server stops serving AniList data as soon as AniList asks. The fee for this server pays for the service (hosting, caching, normalisation), not for a licence on the data, which stays under CC BY-SA 4.0 for TVmaze and under the AniList terms for AniList.

### Use cases

- **Personal TV assistant.** "What's new on streaming tonight?" or "is my show still running?" answered from the schedule and the show card.
- **Anime season guide.** See what airs this season and at what time, then when the next episode of a series comes out.
- **Manga discovery.** Find manhwa or light novels by genre or country, and check whether an anime adaptation exists.
- **Newsletters and watch parties.** Build a weekly list of premieres and finales for a country or a genre.
- **Media research.** Count episodes per season, compare runtimes or trace a creator's career for an article.
- **Trivia and recommendations.** Who voices whom, who else was in a cast, which shows share a writer.

### FAQ

#### Does it cover manga and films?

Manga, manhwa or light novels: yes, through AniList. You get a search and one card per title, with chapter and volume counts plus reading links, but no chapter text. Anime films come from AniList too. Live-action films are not covered, since TVmaze lists series only.

#### Are adult titles included?

No. Anime and manga come the way a visitor without an 18+ account sees them on AniList: adult entries are left out on every tool, while titles AniList rates Ecchi, which it does not count as adult, stay in.

#### Can I reuse the data in my app?

TVmaze data, yes, under CC BY-SA 4.0: credit TVmaze, link each item back, and share derived work under the same licence. AniList data comes under the AniList API Terms of Use: no bulk collection, no backup copy, no list or tracker service, and a link to each AniList page. Posters and photos may belong to networks or studios, so clear those separately.

#### Why did it pick the wrong show?

A bare title takes the single closest match, which can miss when several programmes share a name. Search first, then pass the id.

#### What does a call cost?

Each successful tool call is one event, at the price shown on the [Pricing tab](https://apify.com/mrbridge/tv-anime-mcp/pricing?fpr=mrbridge) for your Apify plan: `tool-action` for `media_get_cast`, `media_tv_schedule`, `media_streaming_schedule`, `media_get_anime` and `media_get_manga`, `tool-read` for every other tool. Paid Apify plans get lower prices. On the free plan, a read costs $0.005 and an action $0.01, so 100 reads come to $0.50 in events. On top of that, your Apify account pays the platform usage of your own Standby run while the server is up, idle minutes included. Errors are never charged, and `maxTotalChargeUsd` caps what one run can spend.

#### Why is the first call slower?

The first call after a quiet period starts a new Standby run on your Apify account, which takes a few seconds. Then it answers quickly, and it shuts down after about 5 idle minutes.

#### Is this server affiliated with TVmaze or AniList?

No. It reads their public APIs, and neither of them endorses it.

#### Your feedback

Found a bug or a show it cannot find? Tell us on the [Issues tab](https://apify.com/mrbridge/tv-anime-mcp/issues?fpr=mrbridge).

More MCP servers, scrapers and data studies from the same team: [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.2.4: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.2.3: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.2.2: pricing events tool-read and tool-action
- 0.2.1: an episode without an air time, as most streaming releases are, no longer gets a UTC timestamp or an hour countdown, since TVmaze fills in noon for it. The next episode then comes with its date alone. An episode summary that holds no letter or digit (TVmaze sends "." for some streaming episodes) now reads as no summary instead of a lone dot. Test fixtures now come from real TVmaze answers captured on the deployed server (private, unpublished)
- 0.2.0: manga from AniList, with `media_search_manga` (title, genre, year, format, status and country of origin, so manhwa and manhua too) and `media_get_manga` (chapters, volumes, staff, reading links, related manga and anime adaptations). The anime card gains `related_manga`. The ChatGPT `search` and `fetch` pair now reads AniList anime and manga as well as TVmaze shows and people, and its ids name their source (`tvmaze:show-82`, `anilist:manga-30002`), while `fetch` still accepts `show-82` and `person-1`. Entries of the Hentai genre are now left out even when AniList does not flag them adult, and Ecchi titles are still served. Server name aligned with the Store title (private, unpublished)
- 0.1.0: initial build with TVmaze, and AniList anime tools added before the first release (private, unpublished)

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--tv-anime-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# 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 = {
    "mcpEndpoint": "https://mrbridge--tv-anime-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/tv-anime-mcp").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 = { "mcpEndpoint": "https://mrbridge--tv-anime-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/tv-anime-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mcpEndpoint": "https://mrbridge--tv-anime-mcp.apify.actor/mcp"
}' |
apify call mrbridge/tv-anime-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/tv-anime-mcp"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zxFIaUkPYB69p7w5e/builds/cq3kXQ2mDqcyNwZ9e/openapi.json