Perplexity Pro allows file uploads up to 25 MB per document and 100 files per month. Storage follows a tiered model: Pro Basic includes 10 GB (overage at $0.10/GB/day) and Pro Unlimited includes 50 GB (overage at $0.05/GB/day). Files uploaded for immediate analysis are automatically cleaned up after 7 days unless explicitly saved.

File Upload Limits on Perplexity Pro

Perplexity Pro imposes specific constraints on file uploads that differ from the free tier. As of 2026, Pro subscribers can upload files up to 25 MB per document and process up to 100 files per month by default. This limit applies to individual files across all supported formats.

The platform accepts several document types for analysis:

For developers working with large codebases or documentation, these limits are sufficient. A typical 50-page PDF averages 1-3 MB, leaving comfortable headroom. However, technical documentation with embedded images can approach the 25 MB threshold quickly.

Storage Cost Structure

Perplexity Pro uses a tiered storage model based on usage hours and storage retention:

Tier Storage Included Overage Rate
Pro Basic 10 GB $0.10/GB/day
Pro Unlimited 50 GB $0.05/GB/day

The storage costs apply only to files you choose to keep in your Perplexity workspace for extended periods. Files uploaded for immediate analysis are processed and then cleaned up automatically after 7 days unless explicitly saved.

For most developers, the base tier provides adequate storage. If you regularly work with large datasets or maintain a knowledge base of documentation, consider the Unlimited plan to avoid unexpected charges.

Practical Examples

Example 1: Analyzing a Technical Specification

Suppose you have a 15 MB PDF containing API documentation:

# This file is well within limits
file_size_mb = 15
max_file_size_mb = 25

if file_size_mb <= max_file_size_mb:
    print("File eligible for upload without splitting")
else:
    print("Consider splitting the PDF into smaller chunks")

Example 2: Processing Multiple Code Review Documents

When analyzing multiple files simultaneously, track your monthly usage:

// Track monthly uploads to avoid hitting limits
const MAX_MONTHLY_UPLOADS = 100;

let uploadsThisMonth = 0;

function uploadDocument(file) {
  if (uploadsThisMonth >= MAX_MONTHLY_UPLOADS) {
    throw new Error('Monthly upload limit reached');
  }
  uploadsThisMonth++;
  // Proceed with upload
}

Example 3: Optimizing Large CSV Files

For data files exceeding limits, consider preprocessing:

# Split large CSV files before upload
split -l 50000 large_dataset.csv chunk_

# This creates smaller files, each under 25 MB
# After analysis, you can delete the chunks

Cost Optimization Strategies

1. Delete Unused Files Promptly

Files remain in your workspace until explicitly removed. Schedule monthly cleanup sessions:

import os
from datetime import datetime, timedelta

def cleanup_old_files(workspace_path, days=30):
    cutoff = datetime.now() - timedelta(days=days)
    removed_count = 0
    
    for filename in os.listdir(workspace_path):
        filepath = os.path.join(workspace_path, filename)
        if os.path.getmtime(filepath) < cutoff.timestamp():
            os.remove(filepath)
            removed_count += 1
    
    return removed_count

2. Use Appropriate File Formats

Text-based PDFs are more efficient than image-scanned documents:

3. Use Concurrent Analysis

Perplexity Pro supports batch processing. Instead of uploading files one-by-one, combine related documents:

# Group related files for batch analysis
documents = [
    "api_spec.md",
    "architecture_diagram.pdf",
    "database_schema.sql"
]

# Upload as a batch to save time
# Each file counts against your monthly limit

Integration Considerations for Developers

When building applications that interface with Perplexity’s API, implement proper error handling:

import requests
import time

def upload_with_retry(file_path, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                "https://api.perplexity.ai/v1/documents",
                files={"file": open(file_path, "rb")},
                headers={"Authorization": f"Bearer {API_KEY}"}
            )
            
            if response.status_code == 413:
                print(f"File {file_path} exceeds 25 MB limit")
                return None
                
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.RequestException as e:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
                continue
            raise e

Summary

Perplexity Pro’s file upload limits and storage costs are designed for typical developer workflows. The 25 MB per-file limit accommodates most documentation and code files, while the 100 monthly uploads provide sufficient capacity for regular usage. By following the optimization strategies above, you can maintain efficient workflow without unexpected charges.

For teams requiring higher limits, Perplexity offers enterprise plans with custom quotas. Evaluate your actual usage patterns before upgrading to ensure the additional cost aligns with your needs.

API Rate Limits for File Operations

Beyond the user interface limits, Perplexity’s API enforces rate limiting on file operations. The current API constraints allow up to 50 requests per minute for file uploads, with burst allowances of up to 100 requests. This matters when building automated pipelines that process multiple documents.

Understanding these limits helps when designing batch processing jobs:

import time
from threading import Semaphore

class PerplexityFileUploader:
    def __init__(self, api_key, max_concurrent=5):
        self.api_key = api_key
        self.semaphore = Semaphore(max_concurrent)
        self.request_times = []
    
    def upload_with_rate_limiting(self, file_path):
        # Wait if we've hit rate limits
        current_time = time.time()
        self.request_times = [
            t for t in self.request_times 
            if current_time - t < 60
        ]
        
        if len(self.request_times) >= 50:
            sleep_time = 60 - (current_time - self.request_times[0])
            if sleep_time > 0:
                time.sleep(sleep_time)
        
        with self.semaphore:
            self.request_times.append(time.time())
            return self._upload_file(file_path)

Common Error Codes

When working with file uploads, you may encounter specific error codes:

Handling these errors gracefully in your code prevents workflow disruptions:

def handle_upload_error(response):
    error_codes = {
        413: "File too large. Split into smaller chunks.",
        429: "Rate limit hit. Implement exponential backoff.",
        422: "Unsupported format. Convert and retry.",
        401: "Authentication failed. Check API key."
    }
    return error_codes.get(response.status_code, "Unknown error")

Built by theluckystrike — More at zovo.one