A workflow MCP server over a self-hosted Jellyseerr / Overseerr instance — the request layer that fronts Jellyfin/Plex/Emby plus Radarr and Sonarr. The unit of work is not "download a movie"; it is search → resolve the exact TMDB-backed title → check availability and request state → create a guarded request that Radarr/Sonarr act on. Jellyseerr owns permissions, quotas, routing, and status; this server never touches Radarr/Sonarr directly.

Two properties make it safe to hand an agent:

• Guarded writes. The one mutating tool (seerr_request_media) defaults to mode: preview — it resolves the title and returns the exact payload that would be submitted without writing anything. The real request fires only on mode: request, which asks for an explicit confirmation and submits only once that confirmation comes back accepted.
• Operator-safe output. Every payload passes through one normalization layer (src/services/seerr/normalizers.ts) that allow-lists the fields it emits, so operator email, Plex/Jellyfin tokens and media-server IDs, and internal serviceUrl hosts never reach the model — requesters are projected to { id, displayName }. Redaction is always on; filesystem paths are the single opt-in, behind includePaths.

Tools

Six tools covering the request workflow — discover (search) → confirm (get) → understand routing (service_options) → request (request_media) → track (request_status / list_requests):

Every status field is decoded to { raw, label } — both the numeric code Jellyseerr returns and a human label — so an agent never has to hardcode the enum mapping.

seerr_search_media

Title disambiguation entry point. Wraps GET /search, filters to movies and TV (people are always excluded), and decodes availability when the title is tracked.

• Free-text title queries matched against TMDB; movie / tv / all media-type filter
• Decoded availability (status, plus status4k when 4K is enabled) for tracked titles only
• Pagination by page, with a per-call result limit to cap output size
• Optional ISO 639-1 language for localized titles/overviews
• Empty results are a normal success — returns [] with a guidance notice, not an error

seerr_get_media

Confirm the exact title before a write. Wraps GET /movie/{id} or GET /tv/{id}, optionally a season's episodes.

• Availability plus any existing open request for the title (avoids duplicate requests)
• TV: omit seasonNumber for a per-season summary, or pass one to fetch that season's episode list (season 0 is Specials)
• A TMDB ID that doesn't resolve surfaces as a clean media_not_found with a search-recovery hint (Jellyseerr's raw HTTP 500 is classified in the service layer)

seerr_list_requests

Review recent requests and their lifecycle. Wraps GET /request.

• Lifecycle filter (pending, processing, available, failed, …), mediaType, and requestedById filters
• Sort by created (added) or last-changed (modified), ascending or descending
• take / skip pagination; the enrichment trailer echoes the filter set the server applied
• Requester is PII-redacted to { id, displayName }
• Titles aren't on request objects. includeTitles: true joins them from the media records — one lookup per distinct title on the page, so a 4K and a non-4K request for one film cost one call. Default is off, keeping the call to a single upstream read. Rows that can't be resolved keep every other field and are disclosed in the notice

seerr_request_media

The only mutation in the surface, and it is triple-guarded:

1. mode: preview (default) resolves the title and returns the exact POST /request payload that would be submitted — no write. A sloppy call shows the payload and changes nothing.
2. mode: request asks for an explicit confirmation and submits only once it comes back accepted. Declining, cancelling, or answering with anything the confirmation schema rejects cancels before submission (request_cancelled) — there is no branch that proceeds without an acceptance, so a client that never answers leaves the write un-run.
3. destructiveHint: true surfaces the risk in client-side approval flows.

Over HTTP this needs MCP_SESSION_MODE to resolve to stateful (the default auto does): 2025-era clients answer the confirmation over a live session, which stateless has no way to hold open.

• Capability validation (4K enabled? seasons valid? partial requests allowed?) runs locally against cached instance settings before any POST, so a bad request fails with an actionable typed error instead of a failed write
• TV requests take seasons: "all" or an explicit list (e.g. [1, 2]); Specials are excluded unless the instance enables them
• Optional routing overrides (serverId, profileId, rootFolder, languageProfileId) — omit to use Jellyseerr's defaults (recommended)
• An existing request for the title is surfaced in the output; a duplicate rejection from Jellyseerr maps to a typed duplicate_request pointing back at it

seerr_service_options

Lets an agent reason about request capability and routing without a separate status tool. Fans out service + settings + version reads with Promise.allSettled, so one failed leg degrades to a disclosed notice rather than failing the call.

• Instance capability summary: Jellyseerr version, media server, and the movie4kEnabled / series4kEnabled / partialRequestsEnabled / specialEpisodesEnabled flags
• Per-service routing: server ID, default-server flag, 4K capability, and the active + available quality profiles (IDs and names, safe to surface)
• Filesystem root-folder paths and free space are operator-private — omitted unless includePaths: true

Resource and prompt

All request data is also reachable via tools — request enumeration is the job of seerr_list_requests (filterable, the tool-only access path), so the collection is intentionally not exposed as a resource. There are no prompts; the guarded-write workflow lives in the tool, not a prompt template.

Features

Built on @cyanheads/mcp-ts-core:

• Declarative tool and resource definitions — single file per primitive, framework handles registration and validation
• Unified error handling — handlers throw, framework catches, classifies, and formats
• Pluggable auth: none, jwt, oauth
• Swappable storage backends: in-memory, filesystem, Supabase, Cloudflare KV/R2/D1
• Structured logging with optional OpenTelemetry tracing
• STDIO and Streamable HTTP transports

Jellyseerr-specific:

• Read + guarded-request only — admin-scope endpoints (approve/decline, retry, edit/delete, media/file deletion, user/settings/sync) are excluded by design, not by API limitation
• Status decoding centralized in one helper — request and media statuses (including the separate 4K availability) decode to { raw, label } everywhere, forward-compatible with new Jellyseerr status codes
• Capability validation against cached instance settings catches most bad requests before they reach the API
• A short-TTL settings cache avoids a round-trip on every preview

Agent-friendly output:

• Provenance and disclosure — searches echo the effective query; capped lists disclose truncation; a degraded service leg surfaces a notice instead of silently dropping data
• Typed, actionable errors — media_not_found, request_not_found, seasons_required, four_k_not_enabled, duplicate_request, and more carry a recovery hint so callers can branch and retry without parsing prose

Getting started

This server connects to your own Jellyseerr/Overseerr instance — there is no public hosted endpoint. Add the following to your MCP client configuration file, pointing SEERR_BASE_URL at your instance and supplying its API key.

{
  "mcpServers": {
    "seerr-mcp-server": {
      "type": "stdio",
      "command": "bunx",
      "args": ["@cyanheads/seerr-mcp-server@latest"],
      "env": {
        "MCP_TRANSPORT_TYPE": "stdio",
        "MCP_LOG_LEVEL": "info",
        "SEERR_BASE_URL": "http://localhost:5055",
        "SEERR_API_KEY": "your-api-key"
      }
    }
  }
}

Or with npx (no Bun required):

{
  "mcpServers": {
    "seerr-mcp-server": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@cyanheads/seerr-mcp-server@latest"],
      "env": {
        "MCP_TRANSPORT_TYPE": "stdio",
        "MCP_LOG_LEVEL": "info",
        "SEERR_BASE_URL": "http://localhost:5055",
        "SEERR_API_KEY": "your-api-key"
      }
    }
  }
}

For Streamable HTTP, set the transport and start the server:

MCP_TRANSPORT_TYPE=http MCP_HTTP_PORT=3010 SEERR_BASE_URL=http://localhost:5055 SEERR_API_KEY=your-api-key bun run start:http
# Server listens at http://localhost:3010/mcp

Prerequisites

• Bun v1.3.2 or higher (or Node.js v24+).
• A running Jellyseerr or Overseerr instance, and its API key (Settings → General → API Key).

Installation

1. Clone the repository:

git clone https://github.com/cyanheads/seerr-mcp-server.git

2. Navigate into the directory:

cd seerr-mcp-server

3. Install dependencies:

bun install

4. Configure environment:

cp .env.example .env
# edit .env — set SEERR_BASE_URL and SEERR_API_KEY

Configuration

All configuration is validated at startup via Zod schemas in src/config/server-config.ts. Key environment variables:

See .env.example for the full list of optional overrides.

Running the server

Local development

• Build and run:

  sh

  Copy

  # One-time build
  bun run rebuild
  
  # Run the built server
  bun run start:stdio
  # or
  bun run start:http
  

• Run checks and tests:

  sh

  Copy

  bun run devcheck   # Lint, format, typecheck, security, changelog sync
  bun run test       # Vitest test suite
  bun run lint:mcp   # Validate MCP definitions against spec
  

Docker

docker build -t seerr-mcp-server .
docker run --rm \
  -e SEERR_BASE_URL=http://host.docker.internal:5055 \
  -e SEERR_API_KEY=your-api-key \
  -p 3010:3010 \
  seerr-mcp-server

The Dockerfile defaults to HTTP transport, stateless session mode, and logs to /var/log/seerr-mcp-server. OpenTelemetry peer dependencies are installed by default — build with --build-arg OTEL_ENABLED=false to omit them.

Project structure

Development guide

See CLAUDE.md/AGENTS.md for development guidelines and architectural rules. The short version:

• Handlers throw, framework catches — no try/catch in tool logic
• Use ctx.log for request-scoped logging, ctx.state for tenant-scoped storage
• Register new tools and resources via the barrels in src/mcp-server/*/definitions/index.ts
• Wrap the Jellyseerr API: validate raw → normalize and redact to a domain type → return the output schema; never fabricate missing fields, and never let operator PII or paths reach output

Contributing

Issues and pull requests are welcome. Run checks and tests before submitting:

bun run devcheck
bun run test

License

Apache-2.0 — see LICENSE for details.