# Perplexity Supported File Types: Formats, Upload Limits, and Workarounds

Perplexity supported file types include PDFs, office documents, spreadsheets, code, images, audio, and video files capped at 40 MB per file. Direct thread attachments face strict parser limits, rolling weekly upload caps, and thread isolation. For large research archives, connecting external cloud workspaces through the Model Context Protocol provides persistent, searchable indexing without hitting upload boundaries.

Source: https://fast.io/resources/perplexity-supported-file-types/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-19

## What Are Perplexity Supported File Types and Upload Limits?

Perplexity supported file types are the document, code, image, audio, and video formats Perplexity accepts for analysis and citation during search queries. The Perplexity Help Center states that file size is limited to 40 MB for all file types, and describes uploads as textual files (plain text, code, or PDFs), images, audio, and video.

The formats Perplexity's help center names fall into five categories:

* **Text and Documents:** PDF (.pdf), Microsoft Word (.docx), Microsoft PowerPoint (.pptx), Plain Text (.txt), and Markdown (.md), plus Google Docs and Slides through connectors. Enterprise File Connectors also list RTF (.rtf) and OpenDocument Text (.odt).
* **Spreadsheets and Structured Data:** Comma-Separated Values (.csv), Microsoft Excel (.xlsx), and JSON (.json), plus Google Sheets through connectors. Enterprise File Connectors also list older Excel (.xls) files.
* **Code and Scripts:** Plain-text source files.
* **Images:** JPEG (.jpg, .jpeg) and PNG (.png).
* **Audio and Video Media:** MP3 (.mp3), WAV (.wav), AIFF (.aiff), OGG (.ogg), FLAC (.flac), MP4 (.mp4), MPEG (.mpeg, .mpg), MOV (.mov), AVI (.avi), FLV (.flv), WEBM (.webm), WMV (.wmv), and 3GPP (.3gpp).

Files over the 40 MB upload limit are rejected, and formats outside these lists may not be readable. When an attachment is accepted, Perplexity extracts its text, transcribes speech, or analyzes images to inform the active search query.

| Format Category | Supported Extensions | Primary Ingestion Action | Max File Size | Processing Constraints |
| :--- | :--- | :--- | :--- | :--- |
| Text Documents | .pdf, .docx, .pptx, .txt, .md | Text extraction; long files are excerpted | 40 MB | Scanned pages need a text layer; password-protected files may not be readable |
| Tabular Data | .csv, .xlsx, .json | Row-to-text conversion | 40 MB | Long sheets may be read selectively; formulas and macros are not run |
| Source Code | Plain-text source files | Text extraction | 40 MB | Large codebases exceed prompt context windows |
| Visual Media | .jpeg, .jpg, .png | Vision model inspection and OCR | 40 MB | Hand-drawn text may fail; query context only |
| Spoken Audio | .mp3, .wav, .aiff, .ogg, .flac | Speech-to-text transcription and speaker labels | 40 MB | Audio-only transcription; background noise degrades accuracy |
| Video Recordings | .mp4, .mov, .avi, .webm, .3gpp | Audio track extraction and transcription | 40 MB | Visual video scenes are not indexed or searchable |

### File Size Limits Across Free, Pro, and Enterprise Tiers

Perplexity enforces different upload ceilings depending on the account tier and the interface used:

1. **Free, Pro, and Max Sessions:** Every consumer plan has a 40 MB file ceiling for all file types and a rolling weekly upload allowance, with Max offering a higher allowance than Pro. Perplexity does not publish the allowance numbers.
2. **Enterprise Sessions:** Enterprise Pro and Enterprise Max users can attach up to 30 files per upload, each up to 50 MB, with up to 100 files per week on Enterprise Pro and 1,000 on Enterprise Max.
3. **Perplexity Projects:** Projects hold persistent files for ongoing work. Every Project supports up to 10,000 files, 5 GB of total storage, and 100 MB per file, the same on every plan.
4. **Perplexity Computer:** On Enterprise plans, Perplexity Computer accepts files of up to 200 MB, enabling deeper analysis of archives and technical datasets.
5. **Perplexity API:** The developer API accepts PDF, DOC, DOCX, TXT, and RTF documents, and Perplexity's API documentation gives Sonar an attachment allowance of 50 MiB per file.

### How Rolling Weekly Attachment Allowances Work

A common point of confusion is how attachment limits are counted. File attachments do not reset daily: they draw against a rolling weekly allowance, and images you attach or paste and files attached from connected apps count toward the same allowance.

Perplexity tracks attached files continuously, with no fixed weekly reset day. Each upload stops counting toward your allowance about one week after you attached it. If an analyst uploads dozens of research documents over two days, Perplexity shows a pop-up (on Pro, possibly suggesting an upgrade to Max) until older files exit the rolling window. Remaining upload allowance is not displayed in account settings, which makes monitoring consumption difficult during intensive research cycles.

## Deep Dive: How Perplexity Parses Each Supported Format

Perplexity processes uploaded files differently depending on whether they hold text documents, tabular data, code scripts, or audio and video. According to Perplexity's help center, short files can be analyzed in their entirety, while for a long file Perplexity extracts the most important parts to answer the query. Text is read from documents and tables, and speech in audio and video is transcribed. Understanding how these parsers operate across each format category reveals why certain files parse cleanly while others fail or return fragmented answers during complex research queries. Each parser balances token economy against text fidelity, influencing how citations are anchored and how follow-up questions interpret contextual data.

### Spreadsheet Parsing: Multi-Tab Workbooks and Formula Degradation

Perplexity accepts spreadsheets in CSV and XLSX formats to help users analyze tabular datasets, financial reports, and survey outputs. However, spreadsheet analysis introduces failure modes that surprise users accustomed to desktop spreadsheet applications.

Perplexity does not document how it treats multi-tab workbooks, live cell references, pivot tables, or macros, so do not assume every tab or calculation survives the upload. An AI tool reads stored values rather than running the workbook's logic, and Perplexity's Microsoft 365 connector does not retrieve macro-enabled workbooks (.xlsm) at all.

Large spreadsheets also consume prompt context rapidly. A CSV file with tens of thousands of rows is a long file, so Perplexity may work from the parts it judges most relevant, and queries requiring cross-row aggregations (such as calculating median revenue across thousands of rows) can produce inaccurate estimates. For reliable results, isolate the specific data table into a focused, single-sheet CSV before uploading.

### Document Parsing: Embedded Text Layers, Scanned PDFs, and OCR

Text documents represent the most common upload category on Perplexity. PDF, DOCX, TXT, Markdown, and RTF files are parsed into searchable text blocks.

For PDF files, the presence of an embedded digital text layer is critical. When a PDF contains selectable text generated by word processors or digital publishing software, the text can be extracted cleanly and cited.

In contrast, scanned PDFs (such as historical public records, signed agreements, or scanned book chapters) contain page images rather than text, so reading them depends on optical character recognition (OCR). Long, low-resolution scans are the most likely to come back incomplete, resulting in partial answers. Pre-processing scanned documents with dedicated local OCR software before upload reduces these extraction failures.

### Audio and Video Files: Speech-to-Text Transcription and Visual Scene Limits

Perplexity supports audio and video uploads, including MP3, WAV, AIFF, FLAC, MP4, MOV, and WEBM formats. The platform processes media files through an automated speech-to-text pipeline that generates searchable transcripts.

During transcription, Perplexity identifies and labels distinct speakers ("who said what") and makes the transcribed text searchable. This capability allows users to ask questions like "What did the chief financial officer say about quarterly margins?" and receive answers grounded in the transcript.

However, a fundamental limitation applies to video uploads: visual scenes inside video files are not indexed or searchable. If an executive presents charts on a slide deck during an MP4 video recording, Perplexity transcribes what the speaker says aloud, but it cannot inspect the visual content of the slides. If the speaker refers to a chart by saying "as you can see from these numbers" without verbalizing the figures, the visual data remains invisible to the AI.

## Parsing Failure Modes and Common Upload Errors

When Perplexity rejects a file or returns unhelpful answers, the failure usually stems from document structure, size boundaries, or content the tool cannot extract. Understanding these failure modes helps teams troubleshoot upload problems quickly.

* **File Size Exceeded:** Uploading a file larger than the official 40 MB limit is rejected. Perplexity's own troubleshooting advice for an unreadable file starts with checking that it does not exceed 40 MB.
* **Corrupted or Password-Protected Files:** Files with encrypted permissions, password protection, or corrupted headers may not be readable, so remove passwords before uploading.
* **Unsupported Formats:** Formats outside Perplexity's documented lists, such as executables, CAD drawings, or raw database files, may not be readable in a search session. In a Project, any file type can be added, but a file Perplexity cannot parse is stored without being searchable.
* **Complex Workbooks:** Spreadsheets that depend on hidden tabs, circular references, or macros are risky to analyze, and Perplexity's Microsoft 365 connector does not retrieve macro-enabled workbooks (.xlsm).
* **Scanned Pages Without Text:** Long PDFs without selectable text can return incomplete content.
* **Rolling Allowance Depletion:** Users who attach numerous files over several days encounter a pop-up indicating that the weekly upload allowance has been reached.

### How to Pre-Process Files Before Uploading to Perplexity

To prevent parsing errors and maximize extraction accuracy, follow these preparation steps:

1. **Flatten Multi-Tab Spreadsheets:** Export the specific tab needed for research into an independent CSV file. Remove empty columns, nested subheadings, and decorative formatting.
2. **Apply OCR Locally:** Run optical character recognition on scanned PDFs using dedicated desktop tools before uploading, confirming that text can be highlighted and copied.
3. **Split Monolithic Manuals:** Divide multi-hundred page handbooks into individual chapter files. Smaller files process faster and generate more accurate semantic chunks.
4. **Strip Password Encryption:** Remove owner and user passwords from PDF documents before attempting to attach them to a search session.
5. **Convert Proprietary Formats to Markdown:** Convert specialized files into clean Markdown or plain text, which parse reliably without formatting artifacts.

### Alternative Ingestion Paths: Perplexity Projects vs. Chat Attachments

Users seeking greater document persistence often turn to Perplexity Projects, which keep searches, files, and instructions together for ongoing work (see also our guide to [Perplexity Spaces file limits](/resources/perplexity-spaces-file-limit/)). According to Perplexity's help center, every Project holds up to 10,000 files and 5 GB of storage, with files up to 100 MB each, on every plan.

While Projects solve the problem of re-uploading documents for every query, they introduce their own storage constraints. Files added from connected apps (such as Google Drive or Microsoft OneDrive) are one-time copies. When team members edit the original files in cloud storage, the copy inside the Project does not update. To maintain current data, users must ask Perplexity to fetch the latest version through the connector or add the file again.

## The Thread-Isolation Problem: Why Prompt Attachments Break Team Research

The fundamental architectural limitation of conversational file uploads is thread isolation. When an analyst uploads a technical specification or legal agreement to a Perplexity search prompt, that file exists strictly within that single thread. Opening a new search session separates the assistant from the document completely.

This thread-bound structure creates three operational bottlenecks for teams:

1. **Repetitive Upload Cycles:** Investigating four related angles across separate threads requires uploading the same large document repeatedly, rapidly consuming the rolling weekly attachment allowance.
2. **Limited Retention:** Perplexity retains uploaded session files for 30 days (7 days on Enterprise plans). After that, the conversation text stays visible but the file contents are no longer available for follow-ups.
3. **Context Window Saturation:** Attaching multiple documents directly to a prompt forces the model to pack raw text into its active context window. As prompt token counts rise, model reasoning degrades, increasing the likelihood that subtle facts in the middle of long documents are overlooked.

Claude encounters a similar structural boundary. In Anthropic's [documented Claude mechanics](https://support.claude.com/en/articles/8241126-upload-files-to-claude), a standard chat accepts up to 20 files at up to 500MB each, while Claude Projects accepts files up to 30MB each with no fixed file-count cap. The practical ceiling on a Claude project is the context window itself. When a research corpus expands beyond what can fit inside an active context window, users must prune reference files or seek a decoupled storage architecture.

### Decoupling Storage from Prompt Context

Production research requires separating persistent document storage from interactive model prompting. Instead of stuffing full documents into individual search prompts, teams maintain their reference archives in an external workspace.

When an AI assistant needs factual evidence, it queries the external repository using search tools. The workspace performs hybrid search across the archive, retrieving only the relevant paragraphs and data points needed to answer the question. This approach preserves prompt context for multi-step reasoning, removes per-prompt attachment limits from the workflow, and keeps all research queries anchored to an identical, up-to-date document collection.

## Connecting External Intelligent Workspaces via MCP for Large Document Corpora

The Model Context Protocol (MCP) provides an open standard for connecting AI assistants and research tools directly to external data repositories. Fastio leaves every vendor's own upload limit where it is; what it adds is a searchable place for the files that do not fit.

Instead of uploading files directly to search prompts or copying static documents into closed spaces, teams assemble their document library in [Fastio intelligent workspaces](/product/workspaces/). Fastio provides shared org-owned workspaces equipped with [Intelligence Mode](/product/ai/). When Intelligence Mode is enabled, uploaded documents are automatically indexed for hybrid search, combining full-text keyword indexing, semantic vector matching, and structured metadata queries.

AI assistants connect to Fastio using the remote MCP server at `https://mcp.fast.io/mcp/tools`. For coding agents, the server address is `https://mcp.fast.io/mcp/code`. Setup procedures and connection parameters are detailed in the [Fastio MCP documentation](https://mcp.fast.io/docs) and the [agent skill guide](https://mcp.fast.io/skill.md).

```json
{
  "mcpServers": {
    "fast-io": {
      "url": "https://mcp.fast.io/mcp/tools"
    }
  }
}
```

Through this connection, the assistant interacts with indexed workspace documents using consolidated MCP tools:

* **`storage` and `storage_manage`:** Inspect workspace directory structures, read file metadata, execute hybrid searches with `action: "search"`, and organize research collections.
* **`workspace` and `workspace_manage`:** Coordinate team workspaces and manage document collections across projects.
* **`upload` and `upload_manage`:** Ingest external research files directly into workspaces through the agent interface.

Advisory file locks are available for collaborative workflows. Agents acquire a lock with `lock-acquire` and release it with `lock-release` on `storage_manage`, checking status with `lock-status` on `storage`. Concurrent writes both land safely, and per-file version history preserves every version.

### Automated Cloud Sync Across Google Drive, Dropbox, Box, and OneDrive

Unlike static connector copies that quickly become outdated, Fastio Cloud Sync maintains active connections with external storage repositories. Cloud Sync connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Teams can also use [Cloud Import](/product/cloud-import/) for immediate one-time data transfers.

When an engineer updates an architectural specification in Google Drive or a paralegal updates an exhibit in OneDrive, Cloud Sync updates the file in the Fastio workspace on your configured schedule. Fastio automatically re-indexes the modified text. AI assistants querying the workspace retrieve current facts, while per-file version history allows teams to review previous iterations or audit modifications over time.

### Structured Document Processing with Metadata Views

When managing collections of contracts, research studies, invoices, or technical data sheets, keyword search alone is not always sufficient. Fastio provides [Metadata Views](/product/document-data-extraction/) to turn unstructured documents into live, queryable databases.

Users describe the fields they want extracted in natural language. The system builds a typed schema (supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time fields), matches documents across the workspace, and populates a sortable, filterable table. It processes PDFs, scanned records, spreadsheets, presentations, and images without manual template configuration. AI assistants can query these structured records through MCP, enabling quantitative comparisons across hundreds of documents simultaneously.

## Best Practices for Structuring Large Document Archives for AI Retrieval

Managing large research collections requires disciplined workspace architecture. When scaling beyond single-file uploads, follow these operational best practices:

1. **Maintain Modular Document Boundaries:** Rather than storing an entire 600-page regulatory filing as a single file, divide the document into logical sections or chapters. Modular files allow search algorithms to pinpoint relevant passages with greater precision.
2. **Organize Projects into Dedicated Workspaces:** Use distinct workspaces for separate research domains or clients. Fastio enforces role-based permissions at the organization, workspace, and share levels, so team members and assistants reach only authorized workspaces and shares.
3. **Audit Repository Changes:** Fastio records workspace modifications in a detailed activity log that tracks uploads, edits, moves, and deletions made by both human collaborators and AI agents.
4. **Distribute Research via Branded Shares:** When delivering research findings to external stakeholders, create branded shares (Send, Receive, Exchange). Shares can be durable or expiring, include per-recipient access controls, and allow administrators to disable file downloads for review-only access.
5. **Preserve Multi-Agent Context:** When multiple AI agents and human researchers collaborate on a project, use per-file version history to track document evolution across iterations.

### Workspace Storage Plans and Capacity Ceilings

Fastio provides predictable storage, compute, and indexing capacity designed for teams and multi-agent systems using dedicated [storage for agents](/storage-for-agents/). Monthly plans start with a 14-day free trial, which requires a credit card.

| Fastio Plan | Monthly Billing | Annual Billing | Storage Included | Member Seats | Monthly AI Credits | Maximum Upload Per File |
| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
| Starter | $9.99/mo | $99/yr | 250 GB | 3 seats | 100,000 | 25 GB |
| Business | $49.99/mo | $499/yr | 5 TB | 10 seats | 600,000 | 50 GB |
| Enterprise | $199.99/mo | $1,999/yr | 25 TB | 30 seats included | 3,000,000 | 100 GB |

Credits meter AI indexing and search operations, while additional storage is available at 1.5 cents per GB per month and extra bandwidth at 4 cents per GB.

## Frequently asked questions

### What file formats can I upload to Perplexity?

Perplexity's help center names text documents (PDF, DOCX, PPTX, TXT, Markdown, plus Google Docs and Slides through connectors), spreadsheets and data (CSV, XLSX, JSON, plus Google Sheets), plain-text code files, images (JPEG, PNG), and audio and video recordings (MP3, WAV, AIFF, OGG, FLAC, MP4, MPEG, MOV, AVI, FLV, WEBM, WMV, 3GPP). Every file must be 40 MB or smaller.

### Can Perplexity read Excel spreadsheets and CSV files?

Yes, Perplexity reads CSV and XLSX spreadsheets. However, it does not document how it handles multiple tabs, formulas, or macros, and it may work from the most relevant parts of a long file rather than every row. For large datasets with thousands of rows, exporting the target table as a focused, single-sheet CSV before uploading produces the most reliable results.

### How do I upload unsupported file types or large document sets to Perplexity?

When files exceed Perplexity file upload limits or use unsupported formats (such as database archives or CAD schematics), store the collection in an external workspace like Fastio. By enabling Intelligence Mode in Fastio workspaces and connecting via the remote MCP server (see [Fastio MCP documentation](https://mcp.fast.io/docs)), AI assistants search and retrieve relevant document excerpts using hybrid search without uploading massive files to the chat prompt.

### What is the maximum file size for Perplexity uploads?

The official maximum file size for Perplexity uploads is 40 MB for all file types in standard search threads. Projects accept files up to 100 MB on every plan, and on Enterprise plans Perplexity Computer accepts files up to 200 MB.

### Does Perplexity transcribe audio and video files?

Perplexity automatically transcribes speech from uploaded audio and video files into searchable text and identifies individual speakers with diarization labels. However, visual scenes, on-screen slides, and motion inside video files are not indexed or searchable.

### Why does Perplexity struggle with scanned PDF files?

A scanned PDF holds page images rather than a text layer, so reading it depends on optical character recognition, and long or low-resolution scans can come back incomplete. Converting scanned files with dedicated local OCR software before uploading makes the text selectable and readable.

## Sources

- [Perplexity Help Center: File Uploads](https://www.perplexity.ai/help-center/en/articles/10354807-file-uploads): Perplexity Help Center documents that file upload size is limited to 40 MB for supported document formats.
- [Perplexity Help Center: FAQ: File App Connectors for Pro subscribers](https://www.perplexity.ai/help-center/en/articles/11185411-faq-file-app-connectors-for-pro-subscribers): Perplexity's file connectors support Google Docs, Slides, and Sheets; PDF, DOCX, XLSX, CSV, and PPTX; and MD, JSON, and TXT files.
- [Perplexity Help Center: Security and Privacy with File Uploads](https://www.perplexity.ai/help-center/en/articles/10354810-security-and-privacy-with-file-uploads): Perplexity retains uploaded session files for 30 days, or 7 days for Enterprise Pro users.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli. MCP setup is at https://mcp.fast.io/docs: Claude and most MCP clients connect to https://mcp.fast.io/mcp/tools, ChatGPT to https://mcp.fast.io/mcp/operations, and coding agents to https://mcp.fast.io/mcp/code.