Document Processing Pipelines

A pipeline is a sequence of API calls that process a document from raw file to structured data. You define each step in the Pulse Playground, test it interactively, then deploy it at scale using the generated SDK code.

Supported Pipelines

The most common valid pipeline configurations are:

Pipeline	Steps	Use Case
Classify → Pipeline	`/classify` → matched pipeline	Route each document to the right pipeline by type before extracting
Extract	`/extract`	Basic content extraction — markdown, tables, figures
Extract → Schema	`/extract` → `/schema`	Extract + apply a schema to get structured data
Extract → Split	`/extract` → `/split`	Extract + split document into topic-based page groups
Extract → Split → Schema	`/extract` → `/split` → `/schema`	Full pipeline — extract, split by topic, apply per-topic schemas
Extract → Tables	`/extract` → `/tables`	Extract + structured table extraction with span detection and cross-page merging
Extract → Charts	`/extract` → `/charts`	Extract + chart reconstruction with source boxes, series data, and exports
Batch Pipeline	`/batch/extract` → `/batch/schema`, `/batch/tables`, `/batch/split`	Process many files through any pipeline in parallel. See Batch Processing.

How It Works

Step 0 (optional): Classify

When you process mixed document types (invoices, bank statements, contracts, …), each type usually needs different extraction settings. Call /classify with the raw document and a set of candidate classifications — each optionally carrying a pipeline_id — and it returns which classification matched, so you can route the document to the right pipeline before extracting. By default, it evaluates the first five pages and costs half the /extract rate.

import json, requests

resp = requests.post(
    "https://api.runpulse.com/classify",
    headers={"x-api-key": "YOUR_API_KEY"},
    files={"file": open("document.pdf", "rb")},
    data={"classify_config": json.dumps({
        "classifications": {
            "invoice": {"description": "Invoices or bills requesting payment.", "pipeline_id": "e5f6a7b8-..."},
            "bank_statement": {"description": "Bank or account statements.", "pipeline_id": "b1a2c3d4-..."},
            # Catch-all with no pipeline_id: classification is forced-choice, so
            # this is what keeps unrecognized documents out of the wrong pipeline.
            "unrecognized": {"description": "Any document that does not clearly match one of the other classifications."}
        }
    })},
)
pipeline_id = resp.json()["classify_output"]["pipeline_id"]
if pipeline_id is None:
    ...  # unrecognized — send to manual review instead of extracting

Classify always returns one of the classifications you supplied — it never reports “no match” on its own. Always include a catch-all class and leave off its pipeline_id, then branch on the null. See Always include a catch-all classification.

If all your documents are the same type, skip this step and start at extract.

Step 1: Extract

Every pipeline’s processing starts with /extract (classify, if used, only decides which pipeline runs). This processes your document and returns markdown content, bounding boxes, and optional figures.

result = client.extract(
    file=open("document.pdf", "rb")
)
extraction_id = result.extraction_id

Storage is enabled by default. The extraction_id returned in the response is used to reference the saved extraction in subsequent pipeline steps. If you explicitly disable storage (storage.enabled: false), the extraction won’t be available for split or schema steps.

Step 2 (Option A): Schema Extraction

For documents where you need structured data from the entire document, call /schema with the extraction_id:

schema_result = client.schema(
    extraction_id=extraction_id,
    schema_config={
        "input_schema": {
            "type": "object",
            "properties": {
                "invoice_number": {"type": "string"},
                "total_amount": {"type": "number"}
            }
        },
        "schema_prompt": "Extract invoice details"
    }
)

Step 2 (Option B): Split Document

For multi-section documents (annual reports, contracts, medical records), call /split to identify which pages contain each topic:

split_result = client.split(
    extraction_id=extraction_id,
    split_config={
        "split_input": [
            {"name": "financials", "description": "Balance sheets and income statements"},
            {"name": "risk_factors", "description": "Risk disclosures and legal disclaimers"}
        ]
    }
)
split_id = split_result.split_id

Step 3: Schema on Split Results

After splitting, call /schema with the split_id to apply different schemas to each topic’s pages:

schema_result = client.schema(
    split_id=split_id,
    split_schema_config={
        "financials": {
            "schema": {"type": "object", "properties": {"revenue": {"type": "number"}}},
            "schema_prompt": "Extract financial metrics"
        },
        "risk_factors": {
            "schema": {"type": "object", "properties": {"risk": {"type": "string"}}}
        }
    }
)

Saved Configurations

Each step’s configuration can be saved to a config library for reuse:

Extraction configs — page ranges, figure settings, chunking options
Split configs — topic definitions with names and descriptions
Schema configs — JSON schemas with prompts and effort settings

When a step uses a saved config, you reference it by ID instead of passing the full configuration inline:

# Using saved config IDs
result = client.extract(
    file=open("document.pdf", "rb"),
    extraction_config_id="abc-123"
)

schema_result = client.schema(
    extraction_id=result.extraction_id,
    schema_config_id="def-456"
)

This makes your pipeline code cleaner and ensures consistency when processing many documents with the same configuration.

From Playground to Production

The Pulse Platform lets you build and test pipelines interactively:

Configure each step using the visual pipeline builder
Run the pipeline on a test document to verify results
Save the pipeline — each step’s config is saved to your library
Export — click the Show Code button in the top-right corner of the extraction results panel

The Show Code feature generates ready-to-use SDK code (Python, TypeScript, or cURL) that replicates your exact pipeline configuration. If your steps use saved presets, the generated code references their config IDs directly — no need to copy-paste JSON schemas.

Deploying at Scale

Once you have the generated code, you can deploy it in production to process documents at scale:

from pulse import Pulse
import os

client = Pulse(api_key=os.environ["PULSE_API_KEY"])

documents = ["invoice_001.pdf", "invoice_002.pdf", "invoice_003.pdf"]

for doc_path in documents:
    # Extract
    result = client.extract(
        file=open(doc_path, "rb"),
        extraction_config_id="your-extraction-config-id"
    )
    
    # Apply schema using saved config
    schema_result = client.schema(
        extraction_id=result.extraction_id,
        schema_config_id="your-schema-config-id"
    )
    
    print(f"{doc_path}: {schema_result.schema_output['values']}")

For high-throughput processing, use async: true on each step and poll for results:

# Start async extraction
job = client.extract(
    file=open(doc_path, "rb"),
    extraction_config_id="your-extraction-config-id",
    async_=True  # Returns immediately with job_id
)

# Poll for completion
result = client.jobs.get_job(job_id=job.job_id)  # Repeat until status is "completed"

See Polling for Results for details on async processing.

Pipeline Steps Reference

Classify

Step 0 (optional) — Route a raw document to the right pipeline by type

Extract

Step 1 — Parse documents into markdown, tables, and figures

Split

Step 2 — Split document into topic-based page groups

Schema

Step 2/3 — Apply schemas to extract structured data

Tables

Step 2 (terminal) — Extract structured tables with span detection and cross-page merging

Batch Processing

Run any pipeline step across many documents in parallel

API Reference

Pipeline Steps

Batch & Pipelines

Forms

Jobs, Results & Webhooks

Account & Usage

Legacy Support

Pipeline Overview

Document Processing Pipelines

Supported Pipelines

How It Works

Step 0 (optional): Classify

Step 1: Extract

Step 2 (Option A): Schema Extraction

Step 2 (Option B): Split Document

Step 3: Schema on Split Results

Saved Configurations

From Playground to Production

Deploying at Scale

Pipeline Steps Reference

Classify

Extract

Split

Schema

Tables

Batch Processing

​Document Processing Pipelines

​Supported Pipelines

​How It Works

​Step 0 (optional): Classify

​Step 1: Extract

​Step 2 (Option A): Schema Extraction

​Step 2 (Option B): Split Document

​Step 3: Schema on Split Results

​Saved Configurations

​From Playground to Production

​Deploying at Scale

​Pipeline Steps Reference

Classify

Extract

Split

Schema

Tables

Batch Processing

Document Processing Pipelines

Supported Pipelines

How It Works

Step 0 (optional): Classify

Step 1: Extract

Step 2 (Option A): Schema Extraction

Step 2 (Option B): Split Document

Step 3: Schema on Split Results

Saved Configurations

From Playground to Production

Deploying at Scale

Pipeline Steps Reference