Skip to content
Log in

Parse overview

Turn full documents into LLM-ready content: every text block, table, and figure with layout, formatting, and bounding boxes.

Parse reads every page and returns the full document content (text, tables, figures, layout, and formatting) with bounding boxes, organized into chunks for LLMs, RAG pipelines, or downstream extraction.

Parse runs on r-1, Reducto’s full-page parsing model. Set settings.model to "r-1" and send the document. You do not need any other settings to get high-quality output.

File size limits: Upload files up to 100MB with the Upload endpoint, or up to 5GB with a presigned URL. You can also pass public URLs or presigned S3, GCS, or Azure URLs directly.

Quick start

from pathlib import Path
from reducto import Reducto

client = Reducto()

upload = client.upload(file=Path("invoice.pdf"))
result = client.parse.run(
    input=upload.file_id,
    settings={"model": "r-1"},
)

for chunk in result.result.chunks:
    print(chunk.content)
import Reducto from 'reductoai';
import fs from 'fs';

const client = new Reducto();

const upload = await client.upload({ file: fs.createReadStream('invoice.pdf') });
const result = await client.parse.run({
  input: upload.file_id,
  settings: { model: 'r-1' },
});

for (const chunk of result.result.chunks) {
  console.log(chunk.content);
}
package main

import (
    "context"
    "fmt"
    "log"

    reducto "github.com/reductoai/reducto-go-sdk"
)

func main() {
    ctx := context.Background()
    client := reducto.New("") // reads REDUCTO_API_KEY

    up, err := client.UploadFile(ctx, "invoice.pdf")
    if err != nil {
        log.Fatal(err)
    }
    out, err := client.Parse(ctx, &reducto.SyncParseConfig{
        Input:    up.Input(),
        Settings: &reducto.Settings{Model: reducto.SettingsModelR1},
    })
    if err != nil {
        log.Fatal(err)
    }
    for _, chunk := range out.ParseResponse.Result.FullResult.Chunks {
        fmt.Println(chunk.Content)
    }
}
FILE_ID=$(curl -s -X POST https://platform.reducto.ai/upload \
  -H "Authorization: Bearer $REDUCTO_API_KEY" \
  -F "file=@invoice.pdf" | jq -r '.file_id')

curl -X POST https://platform.reducto.ai/parse \
  -H "Authorization: Bearer $REDUCTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"input\": \"$FILE_ID\", \"settings\": {\"model\": \"r-1\"}}"

What You Get Back

{
  "job_id": "7600c8c5-a52f-49d2-8a7d-d75d1b51e141",
  "duration": 3.89,
  "result": {
    "type": "full",
    "chunks": [
      {
        "content": "# Invoice\n\nBill To: Acme Corp\n123 Main St...",
        "embed": "# Invoice\n\nBill To: Acme Corp...",
        "blocks": [
          {
            "type": "Title",
            "content": "Invoice",
            "bbox": { "left": 0.1, "top": 0.05, "width": 0.3, "height": 0.04, "page": 1 },
            "confidence": "high"
          }
        ]
      }
    ]
  },
  "usage": { "num_pages": 1, "credits": 2.0 },
  "studio_link": "https://studio.reducto.ai/job/7600c8c5-..."
}

Key fields:

Field What it is
chunks[].content The extracted content, formatted as Markdown (headers become #, tables become Markdown/HTML tables). Ready to pass to an LLM.
chunks[].embed Same text as content. With retrieval.embedding_optimized on, tables are replaced by text summaries.
chunks[].blocks The individual elements (paragraphs, tables, figures) with their positions and types. Useful for highlighting or linking back to source.
result.type Either "full" (content inline) or "url" (content at a URL). Large documents return "url" to avoid HTTP size limits.

Input options

input accepts:

  1. Upload response (reducto://...): the file_id returned by /upload.
  2. Public URL: Reducto fetches the file.
  3. Presigned URL: S3, GCS, or Azure Blob.
  4. Previous job (jobid://...): reparse a document from an earlier job without uploading it again.
result = client.parse.run(input="https://example.com/doc.pdf", settings={"model": "r-1"})
result = client.parse.run(input="jobid://7600c8c5-a52f-49d2-8a7d-d75d1b51e141", settings={"model": "r-1"})

Use /parse_async for large documents or webhook delivery. See Sync vs async.

Options

r-1 needs no options for accurate output. These options change the shape of the output:

Option Use it to Page
retrieval.chunking.chunk_mode Split output into chunks for RAG. Defaults to one chunk. Chunking
retrieval.filter_blocks Drop headers, footers, or page numbers from content and embed. Chunking
formatting.table_output_format Return tables as dynamic (default), html, md, json, or csv. Table output formats
settings.page_range Parse only some pages. Page ranges
settings.return_images Get image URLs for figures, tables, or pages. Processing settings
settings.document_password, timeout, persist_results Handle encrypted files and control how results are kept. Processing settings
spreadsheet.* Control how sheets split into tables. Spreadsheets

Add-ons

Add-on What it gives you Setting
Parse citations Word-level bounding boxes for every word, and cell boxes for tables. settings.return_citations: true
Advanced chart extraction Structured series data for each chart. enhance.advanced_chart_agent: true
LLM enrichment An extra model pass with your prompt. Not recommended for most workloads. enhance.agentic with a prompt

Older settings such as ocr_system, extraction_mode, and summarize_figures only apply to legacy Parse. See Legacy Parse settings.

Troubleshooting

Tables look wrong

Set formatting.table_output_format to "html". HTML keeps merged cells and nested headers that Markdown cannot show.

The response is a URL instead of content

Large documents return result.type: "url". Fetch the chunks from result.url:

import requests

if result.result.type == "url":
    chunks = requests.get(result.result.url).json()
else:
    chunks = result.result.chunks
Password-protected PDF

Pass the password in settings.document_password.

Settings seem to have no effect

Check that the request is not setting a legacy-only option. r-1 ignores ocr_system, extraction_mode, summarize_figures, intelligent_ordering, and agentic entries without a prompt.

Next Steps

Type to search…

escClose