Chaining Steps

Pulse workflows are chains of small, reusable steps. Each step returns an ID that lets the next step reuse work instead of re-uploading or re-processing the same document.

The Golden Path

ID Handoffs

You have	You can call next	Why
`job_id`	`GET /job/{jobId}`	Check async status and retrieve the result.
`pipeline_id` (from `/classify`)	that pipeline, with the same file	Run the pipeline the document was routed to. Classify returns routing metadata, not an extraction — the pipeline’s own `/extract` still runs.
`extraction_id`	`/schema`	Extract structured data from the whole document.
`extraction_id`	`/tables`	Extract table structure from the document.
`extraction_id`	`/charts`	Reconstruct charts from the document or a selected page range.
`extraction_id`	`/split`	Assign pages to topics.
`split_id`	`/schema`	Apply different schemas to topic page groups.
`split_id`	`/tables`	Extract tables scoped to split topics.
`split_id`	`/charts`	Reconstruct charts grouped by split topic.

Extract -> Schema

from pulse import Pulse

client = Pulse(api_key="YOUR_API_KEY")

extract_result = client.extract(file=open("invoice.pdf", "rb"))

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

print(schema_result.schema_output["values"])

Extract -> Tables

extract_result = client.extract(file=open("10k.pdf", "rb"))

tables_result = client.tables(
    extraction_id=extract_result.extraction_id,
    tables_config={
        "merge": True,
        "charts_to_tables": True
    }
)

for table in tables_result.tables_output["tables"]:
    print(table["table_content"])

Extract -> Split -> Schema

extract_result = client.extract(file=open("annual-report.pdf", "rb"))

split_result = client.split(
    extraction_id=extract_result.extraction_id,
    split_config={
        "split_input": [
            {"name": "Financials", "description": "Financial statements and metrics"},
            {"name": "Leadership", "description": "Executives and board members"}
        ]
    }
)

schema_result = client.schema(
    split_id=split_result.split_id,
    split_schema_config={
        "Financials": {
            "schema": {
                "type": "object",
                "properties": {
                    "revenue": {"type": "number"},
                    "net_income": {"type": "number"}
                }
            }
        },
        "Leadership": {
            "schema": {
                "type": "object",
                "properties": {
                    "ceo": {"type": "string"}
                }
            }
        }
    }
)

Extract -> Charts

curl -X POST https://api.runpulse.com/charts \
  -H "x-api-key: $PULSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "extraction_id": "YOUR_EXTRACTION_ID",
    "charts_config": {
      "data_points": 100,
      "agentic_zoom": false,
      "export_formats": ["excel", "csv"]
    }
  }'

The chart call reuses the extraction’s saved figures and OCR. Export URLs are authenticated and consumed after one successful download.

Async Chaining

When you set async: true, wait for completion before passing the result to the next step.

job = client.extract(
    file=open("large-file.pdf", "rb"),
    async_=True
)

while True:
    status = client.jobs.get_job(job_id=job.job_id)
    if status.status == "completed":
        extract_result = status.result
        break
    if status.status in ["failed", "canceled"]:
        raise RuntimeError(status.status)

schema_result = client.schema(
    extraction_id=extract_result["extraction_id"],
    schema_config={"input_schema": {"type": "object", "properties": {}}}
)

Common Mistakes

Passing job_id where extraction_id is required

A job_id is for polling. After the job completes, read the completed result and pass its extraction_id into /schema, /split, /tables, or /charts.

Expecting an extraction_id from /classify

Classify is a routing step, not an extraction: it returns a classification and pipeline_id, and persists nothing. Run the routed pipeline with the same file to produce the extraction_id that downstream steps need.

Disabling storage before downstream steps

Downstream steps need saved extraction artifacts. Keep storage enabled when you plan to chain.

Using Split when a page range is enough

If the target pages are always known, pass pages, a table page_range, or a chart page_range. Use Split when topic location changes by document.

Using Schema for a table-first workflow

Schema is great for named fields. Use Tables when preserving row and column relationships is the product.

Pipeline Overview

See supported API pipeline shapes.

Moving from Platform to Production

Generate chained SDK calls from the Playground.

Start Here

Agent Tools

Core Concepts

Security & Compliance

Help

The Golden Path

ID Handoffs

Extract -> Schema

Extract -> Tables

Extract -> Split -> Schema

Extract -> Charts

Async Chaining

Common Mistakes

Pipeline Overview

Moving from Platform to Production

​The Golden Path

​ID Handoffs

​Extract -> Schema

​Extract -> Tables

​Extract -> Split -> Schema

​Extract -> Charts

​Async Chaining

​Common Mistakes

​Related

Pipeline Overview

Moving from Platform to Production

The Golden Path

ID Handoffs

Extract -> Schema

Extract -> Tables

Extract -> Split -> Schema

Extract -> Charts

Async Chaining

Common Mistakes

Related