Uploading Large Files

For files larger than 100MB, use the presigned URL method. This uploads directly to cloud storage, bypassing the 100MB limit of the standard Upload endpoint.

Method	Max Size	When to Use
Direct upload	100MB	Most files
Presigned URL (this page)	5GB	Large PDFs, high-res scans, large spreadsheets

How It Works

Request a presigned URL from Reducto (no file attached)
Upload your file directly to cloud storage using the presigned URL
Use the file_id with Parse, Split, or Extract endpoints

Step 1: Request a Presigned URL

Call the upload endpoint without attaching a file:

import os
import requests

response = requests.post(
    "https://platform.reducto.ai/upload",
    headers={"Authorization": f"Bearer {os.environ.get('REDUCTO_API_KEY')}"}
)

data = response.json()
file_id = data["file_id"]
presigned_url = data["presigned_url"]

print(f"File ID: {file_id}")
print(f"Presigned URL: {presigned_url[:80]}...")

const response = await fetch('https://platform.reducto.ai/upload', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.REDUCTO_API_KEY}`,
  },
});

const data = await response.json();
const fileId = data.file_id;
const presignedUrl = data.presigned_url;

console.log(`File ID: ${fileId}`);
console.log(`Presigned URL: ${presignedUrl.slice(0, 80)}...`);

import (
    "encoding/json"
    "net/http"
    "os"
)

req, _ := http.NewRequest("POST", "https://platform.reducto.ai/upload", nil)
req.Header.Set("Authorization", "Bearer "+os.Getenv("REDUCTO_API_KEY"))

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

var data struct {
    FileID       string `json:"file_id"`
    PresignedURL string `json:"presigned_url"`
}
json.NewDecoder(resp.Body).Decode(&data)

fmt.Printf("File ID: %s\n", data.FileID)

curl -X POST https://platform.reducto.ai/upload \
  -H "Authorization: Bearer $REDUCTO_API_KEY"

Response:

{
  "file_id": "reducto://50c07046-3bac-4844-8c4b-d1428ed9c8f4",
  "presigned_url": "https://prod-storage.s3.amazonaws.com/50c07046-3bac-4844-8c4b-d1428ed9c8f4?X-Amz-Algorithm=AWS4-HMAC-SHA256&..."
}

Save the file_id now. You’ll need it in Step 3. The presigned URL is only for uploading — you can’t use it to process the document.

Step 2: Upload to Presigned URL

Upload your file using a PUT request to the presigned URL:

import requests

with open("large_document.pdf", "rb") as f:
    response = requests.put(presigned_url, data=f)

if response.status_code == 200:
    print("Upload successful!")

import fs from 'fs';

const fileBuffer = fs.readFileSync('large_document.pdf');

const response = await fetch(presignedUrl, {
  method: 'PUT',
  body: fileBuffer,
});

if (response.ok) {
  console.log('Upload successful!');
}

import (
    "bytes"
    "io/ioutil"
)

fileBytes, _ := ioutil.ReadFile("large_document.pdf")

req, _ := http.NewRequest("PUT", presignedUrl, bytes.NewReader(fileBytes))

resp, _ := http.DefaultClient.Do(req)
if resp.StatusCode == 200 {
    fmt.Println("Upload successful!")
}

curl -X PUT "$PRESIGNED_URL" -T large_document.pdf

No Content-Type header needed. When uploading to presigned URLs, you don’t need to set a Content-Type header — the file will be accepted as-is.

Step 3: Process with Parse, Split, or Extract

Use the file_id from Step 1 (not the presigned URL) with any Reducto endpoint:

from reducto import Reducto

client = Reducto()

# Use the file_id from Step 1
result = client.parse.run(input=file_id)

print(f"Processed {result.usage.num_pages} pages")

import Reducto from 'reductoai';

const client = new Reducto();

// Use the fileId from Step 1
const result = await client.parse.run({ input: fileId });

console.log(`Processed ${result.usage.num_pages} pages`);

import (
    reducto "github.com/reductoai/reducto-go-sdk"
    "github.com/reductoai/reducto-go-sdk/option"
    "github.com/reductoai/reducto-go-sdk/shared"
)

client := reducto.NewClient(option.WithAPIKey(os.Getenv("REDUCTO_API_KEY")))

// Use the FileID from Step 1
result, _ := client.Parse.Run(context.Background(), reducto.ParseRunParams{
    ParseConfig: reducto.ParseConfigParam{
        DocumentURL: reducto.F[reducto.ParseConfigDocumentURLUnionParam](
            shared.UnionString(data.FileID),  // file_id from Step 1
        ),
    },
})

fmt.Printf("Processed %d pages\n", result.Usage.NumPages)

# Use the FILE_ID from Step 1
curl -X POST https://platform.reducto.ai/parse \
  -H "Authorization: Bearer $REDUCTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"input\": \"$FILE_ID\"}"

Complete Example

Here’s the full workflow in one script:

import os
import requests
from reducto import Reducto

# Step 1: Get presigned URL
response = requests.post(
    "https://platform.reducto.ai/upload",
    headers={"Authorization": f"Bearer {os.environ.get('REDUCTO_API_KEY')}"}
)
data = response.json()
file_id = data["file_id"]
presigned_url = data["presigned_url"]

# Step 2: Upload to presigned URL
with open("large_document.pdf", "rb") as f:
    requests.put(presigned_url, data=f)

# Step 3: Process with Reducto
client = Reducto()
result = client.parse.run(input=file_id)

print(f"Successfully processed {result.usage.num_pages} pages")
for chunk in result.result.chunks:
    print(chunk.content[:200])

import Reducto from 'reductoai';
import fs from 'fs';

// Step 1: Get presigned URL
const uploadResponse = await fetch('https://platform.reducto.ai/upload', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${process.env.REDUCTO_API_KEY}` },
});
const { file_id: fileId, presigned_url: presignedUrl } = await uploadResponse.json();

// Step 2: Upload to presigned URL
await fetch(presignedUrl, {
  method: 'PUT',
  body: fs.readFileSync('large_document.pdf'),
});

// Step 3: Process with Reducto
const client = new Reducto();
const result = await client.parse.run({ input: fileId });

console.log(`Successfully processed ${result.usage.num_pages} pages`);

#!/bin/bash

# Step 1: Get presigned URL
UPLOAD_RESPONSE=$(curl -s -X POST https://platform.reducto.ai/upload \
  -H "Authorization: Bearer $REDUCTO_API_KEY")

FILE_ID=$(echo $UPLOAD_RESPONSE | jq -r '.file_id')
PRESIGNED_URL=$(echo $UPLOAD_RESPONSE | jq -r '.presigned_url')

# Step 2: Upload to presigned URL
curl -X PUT "$PRESIGNED_URL" -T large_document.pdf

# Step 3: Process with Reducto
curl -X POST https://platform.reducto.ai/parse \
  -H "Authorization: Bearer $REDUCTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"input\": \"$FILE_ID\"}"

Troubleshooting

403 Forbidden on presigned URL

Cause: The presigned URL has expired.Fix: Presigned URLs expire after a short time (typically 1 hour). Request a new presigned URL and try again.

Upload succeeds but Parse fails

Cause: You might be passing the presigned_url instead of the file_id.Fix: Always use the file_id (starts with reducto://) with Parse, Split, or Extract — not the presigned URL.

Timeout during upload

Cause: Large files on slow connections can timeout.Fix:

Use a wired connection if possible
Consider chunked/multipart upload for files >1GB
Implement retry logic with exponential backoff

Unexpected upload errors

Cause: Using incompatible upload methods or headers.Fix:

Don’t include a Content-Type header — presigned URLs don’t require it
For cURL, use -T filename instead of --data-binary @filename
In Go, use bytes.NewReader() to ensure proper Content-Length handling

Direct Upload

For files under 100MB — simpler, one-step upload.

Parse

Extract text, tables, and figures from uploaded documents.

Batch Processing

Process many large files in parallel.

Async Processing

Use webhooks for long-running jobs.

Get Started

Developer Tools

Core Functions

Workflows and Pipelines

Configurations

Reference

Components

Enterprise Resources

Security and privacy

On-premise Resources

Uploading Large Files

How It Works

Step 1: Request a Presigned URL

Step 2: Upload to Presigned URL

Step 3: Process with Parse, Split, or Extract

Complete Example

Troubleshooting

Direct Upload

Parse

Batch Processing

Async Processing

​How It Works

​Step 1: Request a Presigned URL

​Step 2: Upload to Presigned URL

​Step 3: Process with Parse, Split, or Extract

​Complete Example

​Troubleshooting

​Related

Direct Upload

Parse

Batch Processing

Async Processing

How It Works

Step 1: Request a Presigned URL

Step 2: Upload to Presigned URL

Step 3: Process with Parse, Split, or Extract

Complete Example

Troubleshooting

Related