New: Rakesign. Free, unlimited, legally-binding e-signature.Discover

Parse files into structured content.

One call turns a PDF, a scan, an office file, or a recording into clean markdown and structured JSON, with a bounding box on every block it emits, not only the tables and the pictures.

Look at the page before you pay for it.

Most parsing APIs run the same model over every page and bill you for all of them. We route first. Three pages in four never reach a model at all.

  1. Send the file. That is the whole configuration.

    No schema, no template, no saved config to set up first. Parse takes a URL or a file id and decides how to read it. Override the decision with one field when you already know. Force OCR on a bad fax, force transcription on a recording that arrived as a PDF.

    POST /v1/parseprocessing: autono schema
  2. Read it with the smallest thing that works

    A born-digital PDF has a text layer already. A single-column letter has no layout to solve. Those go through a rule-based pipeline with no GPU, at a fifth of the model price. Only the hard quarter (scans, dense tables, multi-column filings) reaches OCR and rakedoc-nano-2.

    rakedoc-nano-21.2B75% rule-based
  3. Markdown for people. JSON for everything else.

    You get two artifacts from one read. Markdown that a person can open and a model can chunk, and structured JSON that carries the blocks, their page, and their position. Audio skips the markdown and returns the transcript instead, with a detected language and timed segments.

    output.markdownUrloutput.jsonUrl24 languages
  4. Every element keeps its box

    Paragraphs, headings, list items, table cells, figures, footnotes. Each one comes back with the rectangle it occupied. Most parsing services box the pictures and the tables and leave the text as a stream. Boxing the text is what lets a later step redact a clause, sign at an anchor, cite a source region, or show an auditor the exact cell a number came from.

    bounding boxespage + position

One endpoint. Everything that arrives.

The mail room does not sort itself before it reaches you, so Parse does not ask you to sort it first either.

  • Born-digital PDFs

    The text is already in the file. We read it directly, keep the reading order, and charge nothing for it. This is most of what most teams send.

  • Scans, faxes, and photos

    No text layer, skewed pages, a stamp over the total. These go through OCR and rakedoc-nano-2, which is the quarter of the traffic worth spending a model on.

  • Recordings, with speakers

    Transcription in 24 languages, with optional diarization so each turn carries a speaker and a timecode. The transcript comes back in timed segments, not one wall of text.

  • Tables that outgrow a page

    A rate table with a three-level header that runs across a page break stays one table, with the header attached to the rows underneath it. That case is where we tuned hardest.

The parser is ours. So are the weights.

rakedoc-nano-2 is the model that reads the hard quarter. It is #1 among open-weight models on ParseBench and ahead of every frontier LLM, and it is published on Hugging Face under AGPL-3.0, so you can check that yourself.

ParseBench overall
80.1
#1 among open-weight models, fifth overall
Parameters
1.2 B
Runs on any GPU with 8 GB, ~6 pages/s on one H100
Per 1,000 pages
$5.20
At enterprise volume; $10 catalog rate, and only on pages that need the model
Open weights
AGPL-3.0
Run it, inspect it, fine-tune it, keep documents inside your perimeter
ParseBench overall score, leaderboard, including our submitted run
  1. LlamaParse Agentic Plus 86.7
  2. LlamaParse Agentic 82.8
  3. Pulse Ultra 2 81.6
  4. Upstage Document Parse 2 80.6
  5. rakedoc-nano-2 ours, open weights 80.1
  6. anyformat 80.0
  7. KDL-Frontier-Parser-nano-v2 open 79.1
  8. Opus 5.5 (Effort High) 78.8
  9. oi-parser 78.3
  10. Fable 5.1 77.8
  11. LlamaParse Cost Effective 77.7
  12. LightOnOCR-3-4B open 75.6
  13. Nemotron-3.5-Parse 75.1
  14. GPT-5.6 Sol (Reasoning High) 74.4
  15. Gemini 3 Flash (Thinking Medium) 74.1
rakedoc-nano-2, per dimension
  1. Content faithfulness Within 3.5 points of the best on the bench 87.8
  2. Tables Merged headers and all, kept as structure 85.9
  3. Semantic formatting Third overall, behind two LlamaParse Agentic tiers 80.0
  4. Grounding The boxes, scored 75.1
  5. Charts Up 6.8 points on our first model, still our weakest 71.7

Every number here comes from the public ParseBench leaderboard, including our own submitted run. Our score is the mean of three full runs on a single GPU; the overall score moved by less than ±0.1 between runs. Models with no published price are on the chart anyway. We would rather you check the numbers than take our word for them.

You are probably paying to read pages that read themselves.

Parsing is sold per page because per page is easy to bill, not because every page costs the same to read.

What everyone chargesWhat we charge
BillingOne rate per page, whatever is on it.Nothing for the pages a rule can read, which on our own traffic is three in four. The model bills only on the quarter that needs it.
BoxesLayout and table structure as paid add-ons.Included, on every element, including the text. There is no version of Parse that returns a stream of words with no coordinates.
Lock-inA closed model, and a bill that follows your volume forever.The weights are on Hugging Face under AGPL-3.0. Self-host at high utilization and the marginal cost drops below $0.30 per 1,000 pages, on your hardware, with our blessing.
ProofA marketing number from an internal eval.A public leaderboard, a submitted pull request, the commit we ran, and a spread under ±0.1 across three runs. Reproduce it if you want to.

One call. Markdown, JSON, and boxes.

No schema to define first and nothing to configure. The second call below is extract, reusing the same file id. The page is already read, so it is not read again.

import { CloudRakerClient } from "@cloudraker/api";

const client = new CloudRakerClient({ token: "YOUR_API_KEY" });

// 1 - Read the file. Routing is automatic; override it when you know better.
const run = await client.parse({
  body: { file: { url: "https://example.com/rate-filing.pdf" } },
});

console.log(run.output?.markdownUrl); // rendered markdown, time-limited URL
console.log(run.output?.jsonUrl);     // blocks, page, and position

// 2 - Every block carries the rectangle it came from
const parsed = await client.fetch(run.output!.jsonUrl);
for (const block of parsed.blocks) {
  console.log(block.type, block.page, block.bbox, block.text.slice(0, 60));
}

// 3 - The read is attached to the file, not the call. No second parse.
const data = await client.extract({
  body: {
    files: [{ id: run.file.id }],
    schema: {
      type: "object",
      properties: { effective_date: { type: ["string", "null"] } },
    },
    citations: true,
  },
});
console.log(data.output?.value);

Send us the page that breaks it.

The free tier covers thousands of pages a month. Point Parse at your worst filing and read what comes back.