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:
- Upload response (
reducto://...): thefile_idreturned by/upload. - Public URL: Reducto fetches the file.
- Presigned URL: S3, GCS, or Azure Blob.
- 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.chunksPassword-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.
