Skip to main content
Deploying a pipeline creates a stable endpoint that your applications can call. You configure everything in Studio and deployment packages it into a single Pipeline ID. Your code stays simple: upload a document, pass the Pipeline ID, receive results.

​
Pipeline vs Direct API

When you click Deploy, Studio offers two options:
Deploy dialog

Deploy dialog with Pipeline and Direct API options

Pipeline ID encapsulates your entire workflow behind a single identifier. Whether you built a parse-only pipeline or a multi-step flow (parse → extract → edit), your API call looks the same: 
result = client.pipeline.run(
    input=upload,
    pipeline_id="k9xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
)
Benefits of Pipeline ID:
  • Simple integration: One ID, one call, any complexity
  • Update without code changes: Modify settings in Studio, redeploy, and all API calls use the new configuration automatically
  • Team collaboration: Non-engineers can iterate on configurations without touching code
Direct API Call exports the raw configuration as code. You get the exact settings you configured, embedded in your application. For multi-step workflows, this means separate calls for each step: 
# Direct API: multiple calls, explicit config
parse_result = client.parse.run(input=upload, options={"ocr_system": "multilingual", ...})
extract_result = client.extract.run(input=parse_result.job_id, schema={...})
Use Direct API when you need runtime flexibility (changing settings per-request) or want configuration in version control.
For most production use cases, Pipeline ID is the better choice. It keeps your code clean and lets you iterate on document processing independently from your application releases.

​
Using your Pipeline ID

Once deployed, integrate the Pipeline ID into your application: 
from pathlib import Path
from reducto import Reducto

client = Reducto()
upload = client.upload(file=Path("finance-statement.pdf"))

result = client.pipeline.run(
    input=upload,
    pipeline_id="k9798h9mwt0wmq5qz5e45qxbfx7yj4bq"
)

# Access results based on your pipeline type
print(result.result)
For high-volume processing, use the async endpoint: 
job = client.pipeline.run_job(
    input=upload,
    pipeline_id="k9798h9mwt0wmq5qz5e45qxbfx7yj4bq"
)

# Poll for completion or use webhooks
result = client.job.get(job.job_id)
See Async Pipeline API and Async invocation pattern for webhook configuration and batch processing patterns.

​
Managing deployed pipelines

Studio provides tools to manage your pipelines after deployment. Access them from the More Actions menu in the top-right corner of any pipeline.

​
Config History

View all published versions of your pipeline. Each deployment creates a new version with a timestamp, allowing you to:
  • See what configuration was active at any point in time
  • Compare versions to understand what changed
  • Roll back by redeploying a previous version’s settings
Click More Actions → Config History to open the version browser. Select any version to view its configuration.

​
Execution Logs

Track API calls made to your deployed pipeline. Click More Actions → Execution Logs to view recent executions. Use this to verify your integration is working and to debug failed requests.
Execution logs appear once the pipeline has been called via the API. Testing in Studio (clicking Run) doesn’t create execution logs.

​
Duplicate Pipeline

Create a copy of your pipeline to experiment with different settings without affecting production. The duplicate is independent, so you can modify and deploy it separately.

​
Delete Pipeline

Remove a pipeline permanently. This invalidates the Pipeline ID; any API calls using it will fail. Delete only pipelines you’re certain are no longer in use.

​
Updating deployed pipelines

To update a deployed pipeline:
  1. Open the pipeline in Studio
  2. Modify your configuration (settings, schema, instructions)
  3. Test with representative documents
  4. Click Deploy again
A new version is created. The Pipeline ID stays the same, so existing integrations automatically use the updated configuration on their next call.
Changes take effect immediately after deployment. Test thoroughly before redeploying production pipelines.

​
Troubleshooting

  • Verify the Pipeline ID is copied correctly (no extra spaces or missing characters)
  • Confirm the pipeline is deployed, not just saved—check for the deployed indicator in Studio
  • Ensure your API key belongs to the same organization that owns the pipeline
  • Check you’re using the correct Pipeline ID (you may have multiple pipelines)
  • Verify no runtime overrides are being passed in your API call
  • Compare the document format—Studio and API should receive identical files
  • Review Config History to confirm you’re using the expected configuration version
  • Complex documents (many pages, dense tables) take longer to process
  • Multi-step pipelines (parse → extract → edit) have cumulative processing time
  • For batch processing, use the async endpoint to avoid timeout issues
  1. Check Execution Logs to confirm the API call reached Reducto
  2. Run the same document in Studio to see results interactively
  3. For Extract pipelines, use the Compare tab to validate against expected output
  4. Review the underlying Parse results—if Parse misses content, Extract can’t find it

Pipeline Basics

How pipelines orchestrate multi-step document workflows.

Pipeline API Reference

Full API documentation for synchronous pipeline calls.

Async Pipeline API

Process large documents and batches asynchronously.

Studio Quickstart

Build and test your first pipeline from scratch.