jina.ai

What is Jina AI?

Jina AI is a set of APIs and models for turning web pages and documents into clean, structured text that search systems and large language models can use. Its focus is the "search foundation" layer: reading a URL, running a web search, generating embeddings, and reranking results. The practical value is that you can feed it messy web content and get back something closer to what an LLM expects.

What you can actually do with it

• Read a URL as text — point it at a page and get the main content back, with options to strip navigation, ads, sidebars and images.
• Search the web — get search results in a structured format rather than scraping a search engine yourself.
• Embeddings and reranking — convert text to vectors and reorder candidate results by relevance, which is the usual backbone of retrieval-augmented generation.
• Small language models and multimodal handling — the site advertises multilingual and multimodal data support, and offers an OCR mode for image-heavy or complex documents.

Controls that matter in practice

The reader API exposes parameters that map to real trade-offs:

Who it suits

Developers building RAG pipelines, agents, or search products where the bottleneck is getting clean text rather than the model itself. If you already have a scraping stack that works, the main reason to look here is the combination of reader, embeddings and reranker behind one API surface, plus the option to plug it into an LLM as an MCP server.

A concrete starting point

Take one page you currently struggle to parse — a JavaScript-rendered article or a PDF with tables — and run it through the reader with a CSS target selector and a raised timeout. Compare the output against your existing extractor on the same page. If the structure is cleaner, the next step is wiring the embeddings and reranker in front of your model; if not, the reader isn't your bottleneck.

For background, the project is published by Jina AI, and the reader and search endpoints are documented there alongside the API key and rate-limit details.

How can I use the r.jina.ai reader to extract content from a URL?

Use r.jina.ai as a prefix in front of a target URL to fetch that page's content in a clean, readable form. The page evidence describes it as a way to "read a URL and fetch its content," and notes the response can include the URL, title, content and timestamp in JSON format.

A basic pattern is:

https://r.jina.ai/https://example.com/article

The reader returns a cleaned version of the page, which is more useful for feeding into an LLM, a search pipeline or a summarizer than raw HTML. You can tune the fetch with request headers shown on the page:

• X-Engine – pick the browser engine; quality, speed, completeness and accessibility change accordingly.
• X-Timeout – raise it for slow pages, lower it for simple static pages.
• X-Token-Budget – cap token usage; exceeding the limit fails the request.
• X-Target-Selector – extract only matching CSS selectors, e.g. article, .main-content.
• X-Wait-For-Selector – wait for dynamic elements before extracting.
• X-Remove-Selector – strip nav, footer, ads and similar noise.
• X-Retain-Images – remove all images to reduce token usage.
• X-Respond-With – use jina-ocr-v1 for image-heavy or complex documents; the page notes this costs 40× more tokens.
• X-Page – choose a page in a multi-page PDF.
• Accept: application/json – return JSON with URL, title, content and timestamp.

Practical scenario: you are building a research assistant and want to summarize a dozen news articles. Prefix each URL with r.jina.ai, request JSON, and set X-Remove-Selector to nav, footer, .sidebar. The output is far easier to chunk and embed than raw HTML, and the timestamp helps you rank freshness.

Next step: start with the plain prefix and no headers to see the default output, then add X-Target-Selector and X-Remove-Selector only if the result contains boilerplate. If you need search results rather than a single page, the same page lists s.jina.ai for web search and mcp.jina.ai as an MCP server for LLM use. See Jina AI for the current parameter table and rate-limit details.

What are the steps to integrate Jina AI's APIs with an LLM using the MCP server?

Jina AI exposes its search and reading APIs through a single MCP endpoint at mcp.jina.ai, so an LLM client that supports MCP (Model Context Protocol) can call them as tools rather than you writing HTTP glue code. Add that URL as an MCP server in your client's configuration, supply a Jina API key for a higher rate limit, and the model can then invoke the reader and search tools directly. The page states that mcp.jina.ai is the server to add so LLMs can use the APIs.

Steps

1. Get an API key. Create one from the Jina AI account/billing area. The page notes that adding an API key raises your rate limit, and points to a rate-limit table for current numbers. The key is what the MCP server uses on your behalf.
2. Register the MCP server. In your MCP-capable client (for example a desktop LLM app or an agent framework), add mcp.jina.ai as a new MCP server entry and paste the API key where your client expects credentials.
3. Confirm the tools appear. After connecting, the client should list the available Jina tools — typically a URL reader and a web search. The page describes r.jina.ai for reading a URL and fetching its content, and s.jina.ai for searching the web and returning SERPs; the MCP server surfaces these same capabilities to the model.
4. Test with a real prompt. Ask the model to read a specific page or search for a topic. If the call fails, check the key, the endpoint, and whether your client requires a restart to pick up new servers.
5. Tune per-call options where your client allows them. The reader accepts parameters such as response format (Markdown or JSON), a timeout, a token budget, CSS selectors for extraction, waiting, or exclusion, and an OCR mode for image-heavy documents. The page warns that the OCR option (jina-ocr-v1) costs about 40× more tokens, so reserve it for complex documents.

Practical notes

• Search returns five entries by default. In search mode the JSON response is a list of five results, each with URL, title, content and timestamp where available — useful for grounding answers, but budget tokens accordingly.
• Reader vs. search. Use the reader when you already have a URL and want clean content; use search when the model needs to discover sources. Many agents chain them: search first, then read the top results.
• Rate limits and cost. Without a key you are on a lower shared limit; with a key you get more headroom. Token budget and OCR choices are the main cost levers you control per request.

If MCP isn't available in your client

Fall back to direct HTTP: call r.jina.ai with the target URL prefixed, or s.jina.ai for search, from your own tool/function-calling layer. That gives you the same capabilities but requires you to handle auth, retries and response parsing yourself.

Alternatives worth knowing if you are comparing MCP-ready search tooling: Model Context Protocol for the spec and client list, and Anthropic for documentation on using MCP with Claude-based clients.

How do I obtain and use an API key for higher rate limits?

Get a Jina API key from your Jina AI account, then send it with every request to lift the anonymous rate limit. The key is the same credential for the Reader, Search and Embeddings endpoints; a higher limit applies to whichever API you call.

Getting and using the key

1. Sign in at Jina AI and open the API Key & Billing area of your dashboard.
2. Copy the key. Treat it like a password — anyone holding it can spend your quota.
3. Pass it as an Authorization: Bearer <key> header (this is the standard pattern for the r.jina.ai and s.jina.ai endpoints shown on the page; check the docs for the exact header if your client differs).

curl https://r.jina.ai/https://example.com \
  -H "Authorization: Bearer $JINA_API_KEY"

For LLM tool use, the same page notes you can add mcp.jina.ai as an MCP server, which is the cleanest route if you are wiring Jina into an agent rather than calling HTTP directly. Keep the key in an environment variable or secret manager, not in source code, and rotate it if it leaks.

What changes once you have one

The key does not change what the APIs return, only how much you can call them. The page also shows several headers that affect cost and quality, and these matter more than the key itself once you are paying per token:

A practical decision rule

Start with the default pipeline and no extra headers — it is tuned for most sites and LLM input. Add X-Target-Selector first if responses look bloated, because it is the cheapest quality win. Only enable the OCR responder when the page genuinely contains images or complex documents, since the page flags it as costing 40× more tokens. If you are unsure whether you need a key at all, test your workload without one first; if you hit the anonymous limit mid-run, that is your signal to register and authenticate.

What parameters can I adjust to customize the content extraction, such as format or timeout?

You can control extraction quality, shape and cost through request headers on Jina AI's reader and search endpoints. The main knobs are:

• Content format (X-Return-Format) — sets how much detail comes back. The default pipeline is tuned for typical pages and LLM input, so start there and only loosen or tighten it if you see over-filtering or missing text.
• Browser engine (X-Engine) — trades quality and completeness against speed and accessibility. Pick a faster engine for simple static pages, a heavier one for JavaScript-driven layouts.
• Timeout (X-Timeout) — maximum wait for page load. Raise it for slow or script-heavy pages; lower it for simple static pages so failed fetches return quickly.
• Token budget (X-Token-Budget) — caps tokens per request. Exceeding it fails the request, so it doubles as a cost guardrail.
• JSON response (Accept) — returns URL, title, content and timestamp where available. In search mode you get a list of five entries in that structure.
• Pagination (X-Page) — selects which page of a multi-page document such as a PDF to process.
• CSS selectors — X-Target-Selector to extract only matching content (e.g. article, .main-content), X-Wait-For-Selector to wait for elements before extracting (useful for dynamically loaded content), and X-Remove-Selector to strip elements like nav, footer, .sidebar before extraction.
• Images (X-Retain-Images) — stripping all images reduces token usage when you only need text.
• OCR mode (X-Respond-With: jina-ocr-v1) — converts images to Markdown for complex documents, but the page notes it costs 40× more tokens, so reserve it for scanned or layout-heavy material.

Choosing between them

A practical starting point for a news-article pipeline: keep the default format, set X-Target-Selector to article, remove nav, footer, and set a timeout of a few seconds. That combination usually returns clean Markdown at low token cost without touching OCR. You can test headers directly against r.jina.ai for a single URL before wiring them into code, and the same parameters apply when you add mcp.jina.ai as an MCP server for LLM use.

When should I use the OCR feature for image-to-Markdown conversion?

Use the OCR option (jina-ocr-v1) when the meaning you need is trapped inside images—scanned PDFs, photos of documents, charts, tables rendered as graphics, or slides where the text isn't in the HTML. If the page's text is already real text, the default reader pipeline is cheaper and usually good enough. The key trade-off is cost: the page evidence states this mode costs 40× more tokens, so reserve it for cases where the image content is the content.

When it's worth it

• Scanned or photographed pages where a normal fetch returns little or no usable text.
• Documents with complex layout—multi-column PDFs, forms, tables—where you need structure preserved as Markdown.
• Pages where key facts (prices, dates, labels) appear only in images or figures.

When to skip it

• Ordinary articles, docs and product pages with normal HTML text.
• Situations where you only need the page title, headings or a rough summary.
• High-volume crawling where you're paying per token and most pages are text-based.

A practical decision rule

Try the default fetch first. If the returned content is empty, garbled, or missing the section you care about, re-run with OCR on that specific URL. Combine it with X-Target-Selector to extract only the relevant block, which keeps the token bill down, and use X-Page when you're processing a specific page of a multi-page PDF.

Example scenario

You're building an index of municipal meeting minutes. Most are HTML and fetch cleanly. A subset are scanned PDFs; those return almost nothing without OCR. Run the cheap path across everything, flag the near-empty results, then re-process only those with jina-ocr-v1. That keeps cost concentrated where it buys you actual text.

For related tooling on the same problem, see Jina AI's reader and embeddings pages, and if you're converting documents locally, Example-style OCR tools aren't needed here—stick to the hosted reader for consistency.