# Jina AI Remote MCP Server: 22 Web Tools for Your Coding Agent

> Jina AI's official remote MCP server exposes Reader, Embeddings and Reranker APIs as agent tools over Streamable HTTP. It is a hosted endpoint, not a self-hosted package, and the tool list is long enough that server-side filtering matters.

**jina-ai/MCP** — Official Jina AI Remote MCP Server

- Repository: https://github.com/jina-ai/MCP
- Website: https://mcp.jina.ai
- Stars: 867 · Forks: 94
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/jina-ai-mcp

## The problem: giving an agent live web access without writing scrapers

An LLM that only knows its training data cannot answer questions about a page published this morning. The usual fix is to hand the model a scraping tool, then maintain that scraper: headless browsers, HTML cleanup, retry logic, PDF parsing. jina-ai/MCP takes a different route. It is a remote Model Context Protocol server that wraps Jina's Reader, Embeddings and Reranker APIs and exposes them as MCP tools, so an MCP-capable client discovers them the same way it discovers a local filesystem tool.

The target user is someone running an agent client that already speaks MCP: Claude Code, Cursor, LM Studio, OpenAI Codex, or anything else that can reach a remote server. The README lists 22 tools, from read_url (page to markdown) through search_web, search_arxiv, search_ssrn, search_images, expand_query, sort_by_relevance, classify_text, deduplicate_strings, deduplicate_images to extract_pdf. That is a broad surface for a single endpoint, and it is the main reason the project also ships a filtering mechanism described below.

The important framing: this is not a library you import. It is a hosted service at https://mcp.jina.ai/v1. You configure a client to point at it. If you wanted to run it yourself, the repository is a Cloudflare Worker, so self-hosting means forking the source and deploying your own worker with your own credentials.

## How the remote server is wired: Streamable HTTP, tools, and API keys

The transport is Streamable HTTP, per MCP spec 2025-03-26. The README notes that the /sse endpoint is kept as an alias for backward compatibility, which explains why older setup instructions reference a path that no longer describes the transport. If you followed a tutorial that used --transport sse, the README's upgrade warning says to remove the old entry first.

Authentication is a bearer token. Tools fall into three groups by key requirement. Some need no key at all: primer, guess_datetime_url, search_jina_blog, search_bibtex. Some are marked optional, meaning they work without a key but hit rate limits: read_url, capture_screenshot_url, parallel_read_url. The rest require a Jina API key, including search_web, the parallel_* search tools, sort_by_relevance, classify_text, deduplicate_strings, deduplicate_images and extract_pdf. A free key is available from jina.ai.

One design detail worth calling out: search_web_deep reads each search result page and then scores every passage against the query in a single listwise Reranker API call using jina-reranker-v3.5, returning the best paragraph-length passage from each page. The README states this typically takes 2 to 20 seconds. That is a real latency budget to plan around, and it is the clearest example of the server doing multi-step work behind one tool name rather than exposing the pipeline to the model.

## Installing the Jina MCP server in Claude Code, Cursor and Codex

There is no package to install for the hosted server. Configuration is a URL and a header. For clients that support remote MCP servers, the README gives this JSON block, where the Authorization header is optional:

```json
{
  "mcpServers": {
    "jina-mcp-server": {
      "url": "https://mcp.jina.ai/v1",
      "headers": {
        "Authorization": "Bearer ${JINA_API_KEY}"
      }
    }
  }
}
```

After saving the config and restarting the client, the Jina tools should appear in the tool list. If they do not, the first thing to check is whether your client resolves ${JINA_API_KEY}; the README warns that some clients do not support environment variables and require the literal key instead.

For Claude Code the README gives a CLI form. Note the upgrade warning: if you previously added the server with --transport sse, remove it first.

```bash
claude mcp remove -s user jina
claude mcp add -s user --transport http jina https://mcp.jina.ai/v1 \
  --header "Authorization: Bearer ${JINA_API_KEY}"
```

For clients that cannot reach a remote MCP server, the README points to mcp-remote as a local proxy. Here is the Codex form, added to ~/.codex/config.toml:

```toml
[mcp_servers.jina-mcp-server]
command = "npx"
args = [
    "-y",
    "mcp-remote",
    "https://mcp.jina.ai/v1",
    "--header",
    "Authorization: Bearer ${JINA_API_KEY}"]
```

A first real use: ask the agent to read a documentation page and summarise it, which exercises read_url, or to search for a recent paper, which exercises search_arxiv. The README does not document expected output shapes for individual tools, so inspect the returned content in your client rather than assuming a schema.

## Tool filtering: the feature that keeps 22 tools from eating your context

Every MCP tool costs context before any work happens. The model must hold the tool's name, description and schema, and the README states that for LLMs with limited context windows, registering all 22 tools can consume significant space. The server's answer is filtering on the endpoint URL itself, so excluded tools are never registered with the client and the model never sees them.

Four query parameters control this: exclude_tools and include_tools take comma-separated tool names, while exclude_tags and include_tags take comma-separated tags. The README's examples show exclude_tools=search_web,search_arxiv and exclude_tags=parallel,rerank. Because filtering happens server-side, a client pointed at a filtered URL behaves as if the excluded tools do not exist.

This is the most interesting design decision in the project and also the one with the least documentation. The README lists the parameter names and example values but does not publish the full tag vocabulary, so you cannot know every valid tag without inspecting the server or the source. If you plan to filter by tag, verify the tag names against the repository before relying on them. Filtering by explicit tool name is safer because the tool names are fully listed in the tool table.

## Where the hosted model falls short

The clearest limitation is architectural: the server is remote and hosted by Jina. Your queries, URLs and document text go to mcp.jina.ai and to the underlying Jina APIs. For internal pages, unreleased documents or regulated data, that is a reason to stop, not a reason to add a header. The repository is Apache-2.0 licensed, so you can fork and deploy your own Cloudflare Worker, but that is a deployment project, not a configuration change, and the README does not document the self-hosting path.

Availability is another boundary. If the endpoint is unreachable, every tool fails at once; there is no local fallback described. The README does not document retry behaviour, timeouts, or what happens when a tool call fails mid-conversation.

Rate limits apply to the optional tools when no API key is present, and the README links to a rate-limit dashboard rather than stating numbers. It also does not document pricing for the keyed tools, so cost planning has to happen outside this repository.

Finally, the tool list is wide but shallow in one respect: several tools are thin wrappers that assume the model will chain them. read_url returns markdown, but chunking, citation tracking and source attribution are left to the client. If you need a retrieval pipeline with a persistent index, this server is a set of primitives, not the pipeline.

## Alternatives: local MCP servers and self-built scraping tools

The obvious alternative is a local MCP server that runs on your machine and wraps a library you control, for example a filesystem or browser-automation server. The difference is where execution and data live. A local server keeps page content on your machine and works offline for local resources, but you own the scraping, HTML cleanup, PDF handling and search backend. jina-ai/MCP trades that maintenance for a hosted dependency and an API key.

A second alternative is to skip MCP entirely and call the Jina Reader and Embeddings HTTP APIs directly from your own application. You get the same underlying extraction and reranking, full control over when calls happen, and no context-window cost for tool schemas. What you lose is the part MCP provides: the client discovers tools automatically and the model decides when to call them. If your workflow is a fixed script rather than an agent choosing tools, direct API calls are simpler and cheaper to reason about.

A third option is a search-oriented MCP server backed by a different provider. The practical difference is coverage and pricing rather than protocol. jina-ai/MCP bundles search with reading, reranking, classification and deduplication behind one endpoint and one key, which is convenient if you want that whole set and awkward if you only want one piece.

## Maintenance, licence and upgrade cost

The repository's last push was on 2026-08-26, and it is not archived. package.json shows version 1.8.1 with a small dependency set: @modelcontextprotocol/sdk, agents, yaml and zod, plus Biome, TypeScript 5.8.3 and wrangler as dev dependencies. The scripts are the standard Cloudflare Worker set: wrangler deploy, wrangler dev, tsc --noEmit for type checking, and Biome for format and lint. There are no published releases retrieved, so version tracking happens through package.json and commits rather than release notes.

For users of the hosted endpoint, upgrade cost is near zero: the URL stays the same, and the README notes that the /sse path remains an alias. The one migration the README does document is transport-related. Anyone who added the server with --transport sse should remove that entry and re-add it with --transport http, because the underlying transport is Streamable HTTP.

For anyone forking the worker, the cost is different. You inherit the dependency tree, the Wrangler toolchain and the need to track MCP SDK changes yourself. The licence is Apache-2.0, which permits commercial use and modification and includes an explicit patent grant; it also requires that you keep the licence and notice files and state significant changes. That is a summary of the licence text, not legal advice, and if you redistribute a modified worker you should read the LICENSE file in the repository.

## Conclusion

Adopt jina-ai/MCP if you already use an MCP-capable client such as Claude Code, Cursor or LM Studio and want web reading, search and reranking without running your own scraping stack. Do not adopt it if you need a self-hosted server, offline operation, or a guarantee that no query text leaves your network, because the endpoint is hosted at mcp.jina.ai and the API-key tools send your queries to Jina. Before wiring it into a workflow, verify two things: that your client supports remote MCP or can run the mcp-remote proxy, and that your free-tier rate limit is enough for the tools you plan to register. The repository is a Cloudflare Worker deployed with wrangler deploy, so if you need changes, you fork and deploy your own worker rather than installing a package.

## FAQ

### What is jina-ai/MCP used for?

It is a remote Model Context Protocol server that exposes Jina Reader, Embeddings and Reranker APIs as agent tools, covering URL-to-markdown extraction, web search, arXiv and SSRN search, image search, reranking, classification and deduplication. An MCP-capable client connects to https://mcp.jina.ai/v1 and the model can then call those tools.

### Does the Jina AI MCP server need an API key?

It depends on the tool. The README marks primer, guess_datetime_url, search_jina_blog and search_bibtex as not requiring a key, read_url, capture_screenshot_url and parallel_read_url as optional (they work without a key but have rate limits), and the rest, including search_web, the parallel search tools, sort_by_relevance, classify_text, deduplicate_strings, deduplicate_images and extract_pdf, as requiring a Jina API key.

### How do I add the Jina AI MCP server to Claude Code?

The README gives a CLI command: claude mcp add -s user --transport http jina https://mcp.jina.ai/v1 with an Authorization header carrying your bearer token. If you previously added it with --transport sse, the README says to remove that entry first with claude mcp remove -s user jina.

### Can I exclude some Jina AI MCP tools to save context?

Yes. The README documents server-side filtering through query parameters on the endpoint URL: exclude_tools and include_tools take comma-separated tool names, and exclude_tags and include_tags take comma-separated tags. Excluded tools are never registered with the MCP client, so the model does not see them.

### How much does jina.ai cost?

The README does not document pricing. It states that optional tools work without an API key but have rate limits, that a free Jina API key is available from jina.ai, and it links to a rate-limit dashboard for details. For cost figures you have to check Jina's own site.

## Sources

- [Issues](https://github.com/jina-ai/MCP/issues)
- [jina-ai/MCP on GitHub](https://github.com/jina-ai/MCP)
- [License: Apache-2.0](https://github.com/jina-ai/MCP/blob/main/LICENSE)
- [Project website](https://mcp.jina.ai)
- [README](https://github.com/jina-ai/MCP/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jina-ai-mcp