nvNeuralVerge

Jina Reader Alternative: Markdown vs Schema-Guided JSON

A Jina Reader alternative compared: markdown page conversion versus schema-guided JSON extraction, over REST or MCP for agents, at 5 points per call.

By the NeuralVerge team · 13 min read · Updated October 2026

▸On this page

If you searched for a Jina Reader alternative, the real question is what you want back from a page: readable markdown or typed fields. Reader returns markdown, and for reading that is the right shape. NeuralVerge's AI extraction returns schema-guided JSON, which skips the second LLM call that usually follows a markdown fetch. This post compares the two honestly, over API and MCP, and says where I don't know Jina's side.

The short version

  • —The verdict: keep Jina Reader when a model or a person needs to read a page. Choose AI extraction when code or an agent needs a fixed set of fields from a URL or document. They also work side by side.
  • —Who each is for: Reader suits prototypes, summarization, question answering over one page and text ingestion for search indexes. AI extraction suits pipelines that write records, and agents that should receive facts rather than a page of prose.
  • —What NeuralVerge costs: 5 points per AI Extract call, drawn from your plan's monthly allowance. Plans and allowances are on the pricing page. For Jina, check its current pricing and limits; this post does not quote them.
  • —Where to get exact details: the AI extraction guide is the reference for request shape, response fields and the failure cases we tested.

Here is how Jina Reader and similar page-to-text tools compare with NeuralVerge, dimension by dimension:

DimensionJina Reader & similar toolsNeuralVerge
Default outputRaw HTML or markdown; structured fields need selectors, a parser, or a separate AI modeTyped, structured JSON — never raw HTML
Saying what you wantCSS/XPath selectors or parser code, written per siteNothing (structure is inferred), plain-language instructions, or a JSON Schema
When a layout changesSelectors break, often silently, until someone fixes themFields are mapped by meaning, not DOM position — no selectors to maintain
Rendering & infrastructurePick render and proxy options per request, or run headless browsers and proxies yourselfRendering, cleaning and mapping happen underneath one call — no browser fleet or proxies to run
Missing dataDepends on how your parser handles itFields that aren't on the page come back empty rather than guessed
Ready-made sourcesBuild, buy or maintain a scraper for each site300+ sources — corporate registries, company intelligence, marketplaces, professional profiles — each with a documented output schema
Beyond pagesPage retrieval and crawlingCited AI research, Search and contact enrichment on the same account and response envelope
Agent accessREST and SDKs; some ship an MCP serverREST, plus run_extract as a tool on a hosted MCP server — same inputs and outputs
Best fitCrawling whole sites, discovering URLs, very high-volume batches, logged-in or multi-step browser flowsTurning known URLs and documents into clean records, and company or person data you'd otherwise have to scrape
The middle column describes how this category of tools typically works; individual products differ, so check each vendor's current documentation.

How Jina Reader works

The facts below come from Jina's public GitHub documentation for Reader, read once while writing this post. Features and limits change, so treat the current docs as the source of truth.

Reader works on a prefix pattern. Per its docs, you put r.jina.ai in front of a URL and get back the page's main content in an LLM-friendly form. The documentation says it handles web pages, PDFs, office documents and images, with generated alt text for images. A companion s.jina.ai endpoint runs a web search and processes the top results through the same conversion, so you get readable content for each hit instead of a list of links.

The default output is markdown. The documentation describes other response types selected by a request header, including HTML, plain text, screenshots and markdown with metadata at the top, and it describes a JSON response option. It also lists request headers for controlling the rendering engine, a timeout, a token cap on the response, and a CSS selector to limit which part of the page is returned.

On access, the documentation describes the service as free with rate limits, with API keys unlocking higher quotas and extra features such as a hosted proxy option. I don't know Jina's current paid terms or how its limits behave under production load, so I am not going to characterize them. Check the current docs before you plan around them.

One more thing worth being plain about: the documentation describes Reader as content conversion. It does not describe defining a schema and getting typed fields back. That is not a criticism. It is a product doing one job with a very low barrier to entry.

Where Jina Reader is the right call

  • —Putting a page in front of a model. Summarization, question answering over one page and agent browsing all want readable text in reading order.
  • —Prototypes and low volume. A prefix and no signup is the fastest way to see whether an idea works.
  • —Ingesting text into a search index. Passages of readable text are the input for embedding, and markdown is a good shape for it.
  • —Reading and search in one tool. The companion search endpoint returns readable content for each result.
  • —Full control over the extraction prompt. If you want to own the mapping logic and swap models freely, getting clean text and doing the rest yourself is a legitimate design.

What it asks of you downstream

What a tool asks of you is not only the call itself. It is also the code and maintenance around it.

With markdown, you own the extraction layer. You write and version the prompt, choose a model, validate the output against a schema, handle the cases where the model wraps or truncates, and decide what a missing field means. You also pay for the model call, in tokens, every time. For a team that just wants fields, that is work they did not plan on.

How NeuralVerge's AI extraction works

AI extraction is one call that takes a URL or a document and returns typed, structured JSON. According to the product definition, the page is rendered the way a browser would render it, ads and boilerplate are removed, and the remaining content is mapped to fields. You describe the fields you want in plain-language instructions, and can optionally pin them with a JSON schema. It never hands back raw HTML.

The point of the design is that structure is the output, not a follow-up step. AI extraction is also one part of a larger platform: the same account covers AI research with citations, Search, and a catalog of 300+ ready-made sources for company and person records, each with a documented output schema.

Here is what that design gives you, advantage by advantage:

NeuralVerge advantageWhat it means for you
Typed JSON out of every callNo HTML or markdown to parse — the response drops straight into a database, RAG index or tool call
Instructions or a JSON Schema instead of selectorsFields are mapped by meaning, not DOM position, so a layout change doesn't silently break your pipeline
Rendering and cleaning handled for youJavaScript-heavy pages are rendered and ads and boilerplate stripped underneath one call — no browser fleet or proxies to run
Empty, not guessedA field that isn't on the page comes back empty, so missing data is visible instead of invented
Pages and documents through one callThe same request and response shape for a web page and a PDF — one pipeline, not two
300+ ready-made sourcesRegistries, company intelligence, marketplaces and professional profiles with documented schemas — no scraper to build or maintain
REST and MCPAgents call run_extract as an MCP tool on any URL they meet mid-task, with the same inputs and outputs as REST

How the two pipelines differ, step by step

Fetch and render. Both load the page in a way that handles JavaScript. Reader exposes header controls for its engine and timeout; AI extraction handles rendering without asking you to pick.

Clean. Both strip the parts of a page that are not the content: navigation, ads, footers, cookie banners. The only reliable way to compare is to run the same real pages through both.

Shape the output. This is where they diverge. Reader shapes the cleaned content as markdown, or another format you select, so your code receives a document. AI extraction maps the cleaned content to fields and returns an object, so your code receives values.

Everything after the call. With markdown, the pipeline continues: prompt a model with the text, request JSON, validate, retry on failure, handle missing fields. With structured JSON, the pipeline continues at the point where you use the values. The work does not disappear when you use markdown; it moves into your codebase.

Where schema-guided JSON is the right call

  • —Values that go into a database or a CRM. If the next step is writing a record, a call that returns typed fields removes a parsing layer.
  • —Consistent shape across differently laid-out pages. The same fields from twenty different company sites, without twenty selectors and without twenty prompt variations.
  • —Documents and pages through one path. A workflow that mixes PDFs with web pages does not need two different mental models.
  • —Agent tool calls that should return facts. An agent that receives a small typed object spends far less context than one that receives a full page of prose.

What AI extraction does not do

It is not a converter for reading whole pages. If you want an article's full text in reading order, forcing it through a field schema throws away the thing you wanted. It also does not discover pages for you: one call reads one URL or document. Throughput, latency, per-file size limits, scanned documents and table handling are not stated, so measure them on your own files.

Worked examples

One company page, two routes

Take an illustrative case. You want a structured profile for Acme Oy (Finland) from a page at https://example.com/company/acme. The page is a fictional example, and so is the company.

Route one: Reader plus your own extraction prompt. You prefix the URL, receive markdown, and the markdown contains a heading, a few paragraphs of company description, a sidebar block with a founding year and a headcount range, and links to related pages. To get fields, you send that markdown to a model with instructions such as "return name, founded, employees, and country as JSON." You parse the reply. Sometimes the reply arrives wrapped in a code fence or with a sentence of commentary, so you add handling for that. Sometimes the page does not list the headcount, and the model fills in a plausible range, so you add an instruction to return null, and then you test that it obeys.

Route two: AI extraction. You send the URL to the extraction call and describe the fields you want. The response is an object with the fields you asked for, shown in the next section. Fields that are not on the page should come back empty rather than invented. That is the behavior to verify on your own pages; do not take any features page's word for it, this one included.

Neither route is wrong. Route one gives you full control over the prompt, and everything that comes with owning it. Route two gives you a shorter path to a value you can store, at the cost of working within the extractor's field mapping.

When readable text is exactly what you need

Now the opposite case. An agent is asked to summarize a long article about the Finnish market and needs the article text in its context window. The output it needs is prose, in reading order, with headings intact.

Markdown is the right shape here. A prefix-style converter is also very convenient in this situation because there is nothing to configure: the agent, or a person, can prepend the prefix and read the result. If your primary need is "put this page in front of a model," Reader is a good fit and you should feel no pressure to switch.

The split is simple. When the model needs to read the page, you want text. When the code needs to use the page, you want fields.

Moving a pipeline from Reader to AI extraction

If you decide some of your Reader calls should become field extraction, the move is mostly about deleting code:

  1. —List the fields your second LLM call currently pulls out of the markdown. Those become the plain-language instructions.
  2. —If downstream code needs an exact shape, write them as a JSON schema and pass it in the call settings. If you pass no schema, the result comes back as JSON text in the human field and machine is null, as described in the AI extraction guide.
  3. —Run ten real pages through both routes and compare the values, including one page that lacks a field.
  4. —Remove the prompt, the fence-stripping and the retry logic only once the comparison holds. Keep Reader for the paths that still want text.

REST and MCP

The same extraction is reachable two ways, with the same inputs and outputs. Over REST you POST to the run-extract endpoint. Over MCP, NeuralVerge's hosted server at https://mcp.neuralverge.ai/mcp exposes it as the run_extract tool, next to run_search and every data source in the catalog. REST paths keep hyphens while tool names use underscores. AI research is the exception: it runs over REST only.

The REST request for the example above:

curl https://api.neuralverge.ai/functions/v1/run-extract \
  -H "Authorization: Bearer <API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/company/acme",
    "instructions": "Extract the company name, founding year and employee range.",
    "settings": { "country_code": "us" }
  }'

The response, from the product's example, with the fictional company:

{
  "session_id": "11111111-1111-1111-1111-111111111111",
  "kind": "extract",
  "url": "https://example.com/company/acme",
  "machine": {
    "company_name": "Acme",
    "founded": "2019",
    "employees": "50-100"
  }
}

The same call as an MCP tool call:

{
  "tool": "run_extract",
  "arguments": {
    "url": "https://example.com/company/acme",
    "instructions": "Extract the company name, founding year and employee range.",
    "settings": { "country_code": "us" }
  }
}

To connect, add the URL to an MCP client such as Claude, ChatGPT, Cursor, VS Code or Gemini CLI, sign in through the browser and click Allow. There is no key to paste into a config file and nothing to host. The MCP server for Claude post shows the steps, and the client guides cover the others. Connected clients can be revoked under Settings, then API, in the dashboard; their labels start with "Connector:". Parameter details change, so confirm them in the documentation.

Which route to pick depends on who decides what to call. For a scheduled pipeline that extracts the same fields from a known list of URLs, call the REST endpoint from your code. For an agent that decides mid-task which pages to read and what to pull from them, connect over MCP and let it choose. An agent that only needs to read a page is still better served by a prefix-style converter, so reach for run_extract when it needs fields it can act on. If Jina offers an MCP server of its own, check its current documentation; I have not verified it.

Cost and limits

An AI Extract call costs 5 points, the same price the pricing page lists for a Search call. A workflow costs its call count multiplied by 5, set against the monthly points your plan includes. Current plan prices and allowances are on the pricing page, and those numbers win over anything in a blog post. There is no separate MCP rate: a call over MCP costs the same as its REST equivalent, so choosing MCP is an integration decision, not a pricing one.

The charge does not depend on the result. In our own test, a call on one public sample-invoice PDF returned null and was still charged 5 points, so do not assume empty or failed extractions are free. If many of your URLs may not contain what you want, check a sample before running the whole list. With an agent, the model decides the call count, so watch early runs to see how many 5-point calls a task makes.

For the markdown route, the second step costs model tokens on every page, plus the time to maintain the prompt. Compare cost per useful result on your own pages rather than headline per-call prices. We have not run a head-to-head speed or accuracy test against Jina Reader and make no claim about either.

How to decide

Run the same ten real pages through both, count the code you had to write around each result, and work through these questions:

  • —Is the next step reading or using? If a model or a person reads the result, markdown is probably right. If code consumes it, look at structured output.
  • —How much code sits between the fetch and the value? Count the prompt, the validation, the retry logic and the missing-field handling. That is the real cost of the markdown route.
  • —What happens when a field is absent? Test one page that lacks a value. Empty is good. Invented is not.
  • —How do both handle your hardest pages? Include a JavaScript-heavy one and a long one, and compare what comes back.
  • —What are the limits at your volume? Read current rate limits and quotas for any tool you plan to depend on, and ask what happens when you hit them.
  • —Does it handle documents you actually have? Try your real PDFs, not a sample from a features page.
  • —Do you need more than page conversion? If search, research or enrichment are coming, check whether one platform covers them or whether you are adding a tool per capability.
  • —Is the agent-facing shape the same as the direct one? If a tool call and a direct call return different shapes, that is two integrations to maintain.
  • —Can your pipeline absorb an empty, billed call? Handle a null result in code and in the budget.

Frequently asked questions

Is NeuralVerge a drop-in replacement for Jina Reader?

Not exactly. Jina Reader is a prefix-style converter that returns readable content for a URL. NeuralVerge's AI extraction returns typed JSON fields instead, so it replaces Reader when the next step in your pipeline needs fields rather than prose. If you want the whole page as readable text, Reader's default output is closer to what you want.

Can Jina Reader return JSON?

Its public documentation describes a JSON response option, but that wraps the converted page content in a JSON envelope. It does not describe extracting fields against a schema you define. Check the current documentation, since features change.

Do I need to write a schema to use NeuralVerge's AI extraction?

No. Every call includes plain-language instructions describing the fields you want; the JSON schema is optional. If you need the exact same shape on every call, define the fields explicitly in a schema.

Does AI extraction work on PDFs and other documents?

Yes. AI extraction takes a URL or a document, and the content goes through the same field-mapping step once it has been read. Jina Reader's documentation also lists PDF support on the markdown side.

Which is better for a RAG index?

It depends on what the index stores. If it holds passages of readable text to embed and retrieve, markdown is a natural fit. If it holds records with fields you want to filter on, structured JSON saves a parsing step. Many teams keep both, one for passages and one for metadata.

Can I use AI extraction over MCP, or only through the API?

Yes. NeuralVerge's hosted MCP server at mcp.neuralverge.ai/mcp exposes AI extraction as the run_extract tool, alongside Search and the data source catalog. Add the URL to an MCP client, sign in and click Allow. It takes the same inputs, returns the same response shape and is priced the same as the REST call.

Can I use Jina Reader and NeuralVerge together?

Yes, and the split is natural. Use Reader where a model or a person needs to read a page as text, and use AI extraction where code or an agent needs typed fields from a URL or document. They do not depend on each other, so you can adopt one without removing the other.

About NeuralVerge

Give your agents structured, cited, real-world data from 300+ sources and the open web — through one API or MCP server.

AI Extraction on the NeuralVerge blog.