Parse a loss run report into clean claims tables

What you'll build

Loss run report (PDF or spreadsheet, often dozens of pages)

• Reducto Parse with HTML table output
• Every claims table preserved, column for column
• A single structured document you can load into code or an LLM

Setup

Grab an API key from studio.reducto.ai -> API Keys -> Create new API key, then set it and install the SDK:

bash
  export REDUCTO_API_KEY="your-api-key-here"
  pip install reducto

Use any carrier's loss run report: a downloaded PDF, a scan, or an Excel export. No template setup or per-carrier tuning required. Need a sample? Open this loss run report in Reducto Studio, where the report is already loaded. Run the pipeline right there, or download it as a PDF to follow the API steps below.

Step 1: Parse the report

The setting that matters most for a loss run is table_output_format: "html", which preserves the claims tables column for column instead of flattening them. Chunking is disabled so the whole report comes back as one document, and the spreadsheet options apply when a carrier sends the loss run as an Excel file.

python
  from pathlib import Path
  from reducto import Reducto

  client = Reducto()

  upload = client.upload(file=Path("loss_run_report.pdf"))

  parse_result = client.parse.run(
      input=upload.file_id,
      formatting={
          "table_output_format": "html",      # keep every claims table column for column
      },
      settings={
          "extraction_mode": "hybrid",
          "ocr_system": "standard",
      },
      spreadsheet={
          "clustering": "accurate",            # applies when the loss run is an Excel file
          "split_large_tables": {"enabled": True, "size": 50},
      },
      retrieval={
          "chunking": {"chunk_mode": "disabled"},  # keep the whole report in one result
      },
  )

  print(f"Parsed {parse_result.usage.num_pages} pages. Review it in Studio: {parse_result.studio_link}")

If a carrier's report is a low-quality scan with misaligned tables, add agentic table correction (enhance={"agentic": [{"scope": "table"}]}) so a vision model rebuilds them before you read the output.

Step 2: Get the full parsed report

Large reports come back as a result URL to keep the response light. Fetch it and stitch the chunks together so you have the entire report as one string.

python
  import json
  import urllib.request

  result = parse_result.result
  if result.type == "url":
      with urllib.request.urlopen(result.url) as response:
          data = json.load(response)
      full_content = "\n".join(c.get("content", "") for c in data.get("chunks", []))
  else:
      full_content = "\n".join(c.content for c in result.chunks)

  print(f"{len(full_content):,} characters of structured content")

full_content is the entire report as clean HTML tables, every claims row preserved column for column, ready to load into a dataframe, a database, or an LLM prompt.

Prefer no code?

Want to see it run first? Open this shared Studio pipeline with the sample report already loaded and press Run. To build your own in Reducto Studio, upload a loss run, set the table output format to HTML, and Run. Review the parsed tables side by side with the source, then Deploy the config as an API endpoint for the rest of your reports.

Where this goes next

Parse turns the report into clean tables. Chain the rest of the toolkit onto the same pipeline:

• Pull typed fields with Extract: turn the parsed tables into a schema (claim number, status, loss paid, expense paid) for direct loading.
• Sort first with Classify: route loss runs, declarations pages, and applications to the right pipeline.
• Break apart submissions with Split: divide a multi-carrier renewal packet into one report per carrier.
• Hand clean data to an LLM or agent: the structured tables drop straight into an underwriting model, a RAG index, or a claims agent.