LlamaParse Alternative: Schema-Pinned JSON From Any Document

A llamaparse alternative depends on what you need back from a document. LlamaParse is built around parsing files you upload into text a model can read. NeuralVerge's AI extraction takes the address of a public page or PDF and returns the fields you described as JSON, pinned to a schema if you pass one. It runs over API or MCP, at 5 points per call. This comparison covers where each fits, with a recorded call and a migration path.

The short version

• —The verdict: pick a file parser when the job is turning uploaded files, in many formats, into readable text for chunking and retrieval. Pick NeuralVerge when the job is getting a fixed set of typed fields out of documents that sit at a public URL. They can also sit in one pipeline: one reads, the other fills the fields.
• —Who each is for: a parser suits retrieval pipelines that start from a pile of files. NeuralVerge suits pipelines and agents that want rows, not text, from public PDFs and pages.
• —The honest constraint: the input is a URL, not a file upload. If the document is not reachable at a public address, NeuralVerge is not the right tool as the product pages describe it today.
• —What NeuralVerge costs: 5 points per AI Extract call, drawn from your plan's monthly allowance. Allowances are on the pricing page. For LlamaParse, check its current pricing; this post does not quote it.
• —MCP: extraction is the run_extract tool on NeuralVerge's hosted MCP server.

At a glance, with competitor statements limited to what the vendor describes publicly (confirm each against its current documentation):

How LlamaParse works

LlamaParse is publicly described as a document parsing service from the team behind LlamaIndex. You send it a file, it reads the layout, tables and text, and it returns the content in a form a language model can use, with markdown as the usual example. Its pricing is described as credit-based. LlamaIndex also describes a separate capability for pulling structured fields out of documents. The product evolves quickly, so check its documentation for the current list of formats, modes and prices before you rely on any of this.

The design goal is easy to see: a retrieval pipeline starts with files, and the first problem is getting clean text out of them, tables and multi-column layouts included. A parser that keeps the document's structure in the output solves that, and it sits naturally inside the LlamaIndex ecosystem.

Where a file parser is the right call

• —Files you hold. Contracts in a shared drive, scans from a back office and attachments from a mailbox are files, not addresses. A service that accepts an upload covers them. A URL-based tool does not.
• —Text for retrieval. If the next step is chunking, embedding and search, parsed markdown is already in the shape the index wants.
• —Many formats. If your inputs include office documents and presentations as well as PDFs, check whether the parser covers them. NeuralVerge's product pages speak of public pages and PDFs, and say nothing more.
• —Layout-heavy and scanned documents. A service built around parsing may have specific modes for difficult layouts or scans. We make no such claim for AI Extract and have not tested it.
• —Staying inside LlamaIndex. If the rest of your stack is already LlamaIndex, a parser from the same project is the shortest path.

What both have in common

Both turn a document into something a program can use, instead of leaving you with a PDF viewer. Both depend on a model reading the content rather than on position-based rules, and both leave you responsible for checking the output. A regular expression or a template written for one supplier's invoice breaks on the next supplier's layout. A tool that reads the content by meaning does not depend on where a value sits on the page. That shared advantage is the reason to use either over a hand-built parser. Where they diverge is the default result and how a document reaches the service.

NeuralVerge as a llamaparse alternative

NeuralVerge's AI extraction is one call. You send a url, plain-language instructions and, optionally, a JSON Schema. The URL can be a web page or a PDF. The product describes the steps as render or parse, strip what is not content, and map what is left to your fields. The full breakdown of AI extraction covers each step and what we tested.

The practical difference is what comes back. A parser returns the document; you then decide what to do with it. AI Extract returns the fields. If the next step is "get these seven values into a table", a call that returns typed JSON skips the pass where you, or a second model call, pull values out of parsed text. If the next step is "index the whole document for search", a parser is the closer fit.

Where NeuralVerge's extraction is the right call

• —Fields as the default result. The result is JSON, and with a schema the typed object is in machine. There is no parse step followed by an extraction step to plan around.
• —The schema is part of the request. The shape is pinned where the call is made, as a string in settings.extract_schema_json, so every document of one type comes back with the same keys. A pinned shape tells you the keys and types; it does not prove the values, so validate them.
• —Public documents at scale. Filings, tender notices, data sheets, regulatory forms and similar documents are already at an address. For those, you skip an upload step and a storage step.
• —One account for the rest. The same account, points balance and response envelope cover extraction, Search, AI research and the ready-made data source catalog, rather than extraction being a separate product.
• —A tool an agent can call. The same capability is run_extract on the hosted MCP server, so an agent that meets a document link can ask for typed fields directly.

What NeuralVerge's extraction does not do

It does not accept a file upload, as far as the product pages describe. It reads one page or document per call. It does not crawl, log in or fill forms. The product pages make no claim about scans, handwriting, page limits or file size, and this article does not either. If any of those are essential, treat NeuralVerge as untested for your case until a sample run says otherwise.

Worked example and migration

The recorded call below is real, with one limit: it is a modest test. It was made on 2026-10-29 through the run_extract tool, on the public IRS Form W-9, a three-page US government form with a fixed layout, at https://www.irs.gov/pub/irs-pdf/fw9.pdf. It shows that the mechanism works on a real PDF. It says nothing about how a scanned, 200-page or unusual document behaves, and we have not run a head-to-head test against LlamaParse. We make no accuracy or speed claim about either.

A real call: a PDF to schema-pinned JSON

The request had three parts: the url, plain-language instructions, and a JSON Schema passed as a string in settings.extract_schema_json.

{
  "url": "https://www.irs.gov/pub/irs-pdf/fw9.pdf",
  "instructions": "Extract the form identity and the entries a filer provides in Part I.",
  "settings": {
    "extract_schema_json": "{\"type\":\"object\",\"properties\":{\"form_number\":{\"type\":\"string\"},\"form_title\":{\"type\":\"string\"},\"revision_date\":{\"type\":\"string\"},\"issuing_agency\":{\"type\":\"string\"},\"part_one_line_labels\":{\"type\":\"array\",\"items\":{\"type\":\"string\"}}},\"required\":[\"form_number\",\"form_title\",\"revision_date\",\"issuing_agency\",\"part_one_line_labels\"]}"
  }
}

The response, with the human field and one long label shortened where marked:

{
  "session_id": "1638d1b3-3ec2-4574-a3e5-c73f1476fa95",
  "kind": "extract",
  "url": "https://www.irs.gov/pub/irs-pdf/fw9.pdf",
  "used_url": "https://www.irs.gov/pub/irs-pdf/fw9.pdf",
  "instructions": "Extract the form identity and the entries a filer provides in Part I.",
  "settings": { "has_schema": true, "extract_schema_json": { "...": "the schema above, expanded" } },
  "human": "# Form W-9: Request for Taxpayer Identification Number and Certification\n\nForm W-9 is used to request a U.S. person's correct Taxpayer Identification Number (TIN) and to certify certain information. ... [shortened]",
  "machine": {
    "form_number": "W-9",
    "form_title": "Request for Taxpayer Identification Number and Certification",
    "revision_date": "March 2024",
    "issuing_agency": "Internal Revenue Service",
    "part_one_line_labels": [
      "Name of entity/individual.",
      "Business name/disregarded entity name, if different from above.",
      "Check the appropriate box for federal tax classification of the entity/individual whose name is entered on line 1. Check only one of the following seven boxes.",
      "If on line 3a you checked “Partnership” or “Trust/estate,” ... See instructions . . . . . . . . .",
      "Exemptions (codes apply only to certain entities, not individuals; see instructions on page 3):",
      "Address (number, street, and apt. or suite no.). See instructions.",
      "City, state, and ZIP code",
      "List account number(s) here (optional)",
      "Social security number",
      "Employer identification number"
    ]
  },
  "total_points": 5
}

How to read it:

• —machine is the typed object, with exactly the keys in the schema. human is a markdown rendering for a person skimming the result, which is also the nearest thing to a parser's output you get from this call.
• —url and used_url are the address you sent and the one that was read. Store them with every record as provenance.
• —total_points is the cost: 5.
• —The extraction was faithful but not tidy. The schema asked for line labels and the long instruction fragments printed on the form came back as part of them. Typed does not mean normalised. If code needs a short name for each line, ask for one as a separate field.

The same document sent with instructions only, and no schema, also cost 5 points. machine was null and the result arrived as JSON text inside human. So whenever downstream code depends on the keys, pass a schema. The details are in the PDF to JSON article.

Illustrative: a supplier file at Acme Oy

Suppose a finance analyst at Acme Oy, a fictional Finnish company, wants the same five fields from every supplier certificate that suppliers publish as PDFs. This is a narrative, not a captured run, and contains no real values.

With a parse-first tool, each PDF goes through the parser, and the markdown then goes into a second step that finds the five fields, either a second capability of the same vendor or your own model call. With NeuralVerge, one call per URL returns the five fields in machine, and the analyst's code checks that dates parse and that missing values are null. If the certificates arrive by email and are not published anywhere, the NeuralVerge route is closed until they are hosted at an address, and that is a good reason to keep the parser.

Moving a step from LlamaParse to NeuralVerge

If your documents are at public URLs and the parse step exists only to feed an extraction step, the migration is small because the input is only an address:

1. —List the fields your code reads. Write the names and types. These become the instructions and, for a fixed shape, a JSON Schema.
2. —Run a sample of real documents. Include one where a field is absent, and compare with what your current pipeline produces.
3. —Pin the shape. Pass the schema as a string in settings.extract_schema_json and read machine. Without a schema, machine is null and the result is JSON text in human.
4. —Keep the parser for what it does. Documents that are private files, scans or other formats stay with the tool that accepts uploads. Replace only the document-to-fields step for the ones that do not.
5. —Handle empty calls. A call that comes back null is still billed 5 points, so add a null check and budget for it.

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 with a bearer API key. Over MCP, NeuralVerge's hosted server at https://mcp.neuralverge.ai/mcp exposes it as the run_extract tool, next to Search and the data sources. Tool names use underscores where REST paths use hyphens. AI research is the exception: it runs over REST only.

The REST request, as the product page documents it:

curl https://api.neuralverge.ai/functions/v1/run-extract \
  -H "Authorization: Bearer <API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.irs.gov/pub/irs-pdf/fw9.pdf",
    "instructions": "Extract the form identity and the entries a filer provides in Part I.",
    "settings": { "extract_schema_json": "<the schema above, as a string>" }
  }'

The same call as an MCP tool call, which is the path the recorded W-9 response came from:

{
  "tool": "run_extract",
  "arguments": {
    "url": "https://www.irs.gov/pub/irs-pdf/fw9.pdf",
    "instructions": "Extract the form identity and the entries a filer provides in Part I.",
    "settings": { "extract_schema_json": "<the schema above, as a string>" }
  }
}

Only the MCP response was captured, so no REST response is shown. Endpoint and parameter details live in the documentation.

Use REST from a batch job or a queue. Use MCP when an agent meets a document link while doing something else: a company page links to its annual report, a registry entry links to a filing. The agent asks for the fields the current task needs and gets JSON back, and its context window is not spent on forty pages of text. Setup for a client is in the guide to connecting the MCP server.

Cost and limits

AI Extract is a flat 5 points per call. The product page puts it as "regardless of page size", and the pricing page lists it in the action costs beside Search, also 5 points. Both W-9 calls cost 5, with and without a schema. There is no separate MCP rate: a call over MCP costs the same as its REST equivalent.

• —You can budget from counts. Number of documents multiplied by 5 points, plus retries. Check the pricing page for what a point is worth in money on your plan.
• —A null result is billed too. A call on a PDF address that no longer existed returned null and was still charged 5 points. A URL that does not load is not free, so check that every address loads before a batch run.
• —Compare cost per useful result. Credit models differ between tools and between modes of one tool. A per-page credit and a per-call point are not the same unit, so compare on your own documents rather than headline prices. For LlamaParse, pricing and limits are on its own site.

The edges of what we know:

• —One call, one document. The W-9 is three pages. Size and page limits are not stated, so if you need every line item of a long price list, confirm the output includes them all.
• —Text PDFs only, in our test. The product pages make no claim about OCR, scanned images or handwriting.
• —It reads what is there. If a value is not in the document, the right answer is an empty field. The no-schema W-9 run returned null for lines with no description, which is the right behaviour, but one form is not a guarantee. Test with a document that lacks a field.
• —It does not tell you whether the document is true. Extraction reports what a filing says. Where a claim matters, corroborate it with a second source.
• —No accuracy or speed figure. No measured numbers exist to quote, so none are given.

How to decide

Run the same five real documents through both and compare the output next to the originals, then work through these questions:

• —Where do your documents live? At a public address, NeuralVerge can read them. In private storage or a mailbox, you need a tool that accepts uploads.
• —What should the result look like? Readable text for an index points to a parser. Typed fields for a table or a ranking step point to schema-pinned JSON.
• —Is structure a separate step? Count the extra capability or model call if extraction runs after parsing, and multiply it by your volume.
• —What happens to absent fields? Ask for something you know is missing. An empty value is useful; a plausible guess is a problem.
• —Does one schema hold across publishers? Test at least ten documents from different sources.
• —How hard are your worst files? Run the biggest, the scanned and the oddly laid out ones. This is where a parser built for difficult layouts may earn its place, and where our claims stop.
• —Does an agent need it mid-task? Then check that the tool is callable over MCP and returns the same shape as the direct API.
• —Can both stay? A parser for uploaded files and a URL-based extractor for public documents is a reasonable split, not a contradiction.

Frequently asked questions

Can NeuralVerge parse a file I upload, the way LlamaParse does?

No, not as far as the product pages describe. AI Extract takes a url, so the page or PDF has to be reachable at a public address. The product pages describe no file-upload route. If your documents sit in private storage or arrive as email attachments, check the documentation for what is supported before you design around it.

Is this a replacement for LlamaParse inside a LlamaIndex pipeline?

Only for the part of the pipeline that needs typed fields. If your pipeline wants parsed text or markdown to chunk and embed, a parser is the closer fit. If it wants a fixed set of fields per document, a call that returns schema-pinned JSON replaces the parse-then-extract sequence for documents you can reach by URL.

What does it cost to extract one document?

AI Extract costs a flat 5 points per call, as the product page and the pricing page state it. A call on a PDF address that no longer loaded returned null and was still billed 5 points, so check that URLs load before a batch run. For LlamaParse, check its current pricing page; this article does not quote it.

Does the JSON Schema guarantee the values are right?

No. A schema pins the keys and types, so downstream code gets a predictable shape. It does not prove the values are correct. Validate the values, ask for a supporting quote as a field, and compare a sample of outputs with the original documents.

Does it handle scanned documents, handwriting or long files?

The product pages make no claim about scans, handwriting, page limits or file size, so this article does not either. The recorded test was a three-page text PDF. Run your worst scan and your longest file before you commit.

Can I use NeuralVerge extraction over MCP from an agent?

Yes. AI extraction is the run_extract tool on NeuralVerge's hosted MCP server at https://mcp.neuralverge.ai/mcp. It takes the same inputs, returns the same typed JSON as the REST endpoint and costs the same 5 points. An agent that meets a document link mid-task can ask for exactly the fields it needs.