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

> Documentation Index
> Fetch the complete documentation index at: https://docs.reducto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Parse overview

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](/parse/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](/upload/overview), or up to 5GB with a [presigned URL](/upload/large-files). You can also pass public URLs or presigned S3, GCS, or Azure URLs directly.

> **Note:** Starting December 7, 2026, Parse defaults to r-1. To keep legacy Parse, set `settings.model` to `"legacy"`. For large, cost-sensitive workloads, use [r-1 mini](/parse/r-1#r-1-mini) with `settings.model: "r-1-mini"`.

## Quick start

**Python**

```python
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)
```

**Node.js**

```javascript
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);
}
```

**Go**

```go
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)
    }
}
```

**cURL**

```bash
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

```json
{
  "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.                                          |

- [Response Format Details](/parse/response-format): Full breakdown of chunks, blocks, bounding boxes, and confidence scores.

---

## 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.

```python
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](/workflows/async-overview).

## 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](/configs/parse/chunking-methods) |
| `retrieval.filter_blocks` | Drop headers, footers, or page numbers from `content` and `embed`. | [Chunking](/configs/parse/chunking-methods) |
| `formatting.table_output_format` | Return tables as `dynamic` (default), `html`, `md`, `json`, or `csv`. | [Table output formats](/configs/parse/table-output-formats) |
| `settings.page_range` | Parse only some pages. | [Page ranges](/configs/parse/page-ranges) |
| `settings.return_images` | Get image URLs for figures, tables, or pages. | [Processing settings](/configs/parse/settings) |
| `settings.document_password`, `timeout`, `persist_results` | Handle encrypted files and control how results are kept. | [Processing settings](/configs/parse/settings) |
| `spreadsheet.*` | Control how sheets split into tables. | [Spreadsheets](/configs/parse/spreadsheet) |

## Add-ons

| Add-on | What it gives you | Setting |
| --- | --- | --- |
| [Parse citations](/configs/parse/citations) | Word-level bounding boxes for every word, and cell boxes for tables. | `settings.return_citations: true` |
| [Advanced chart extraction](/configs/parse/chart-extraction) | Structured series data for each chart. | `enhance.advanced_chart_agent: true` |
| [LLM enrichment](/configs/parse/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](/configs/parse/legacy).

## 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`:

```python
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

- [Response Format](/parse/response-format): Full breakdown of chunks, blocks, and bounding boxes.

- [Best Practices](/parse/best-practices): Optimization by document type, latency tips.

- [Choosing a parser for RAG](https://reducto.ai/guides/best-document-parsers-rag): Reading order, tables, layout-aware chunks, and citations compared across parsers.

- [Comparing parsing accuracy](https://reducto.ai/guides/most-accurate-ocr-software): Which metrics to compare for character recognition, layout, and table extraction.

Source: https://docs.reducto.ai/parse/overview/index.mdx
