# Copilot File Size Limit: Document Ceilings Across Microsoft Copilot & Studio

The Copilot file size limit is 50MB per file, with up to 20 files per conversation, in Microsoft Copilot chat, and 15MB per file for documents users send to Copilot Studio agents, while administrative knowledge base ingestion supports up to 512MB per file. While runtime uploads to Copilot Studio agents are capped at 40 pages per PDF, makers can ingest up to 500 files into custom knowledge bases. Understanding these distinct ceilings prevents upload failures and shows when teams need external workspace indexing.

Source: https://fast.io/resources/copilot-file-size-limit/
Author: [Tom Langridge](https://fast.io/authors/tom-langridge/)
Last reviewed: 2026-10-16

## What Is the Copilot File Size Limit Across Microsoft Chat and Studio?

The Copilot file size limit is 50MB per file, with up to 20 files per conversation, in Microsoft Copilot chat, and 15MB per file for documents users send to Copilot Studio agents, with administrative knowledge base ingestion supporting up to 512MB per file. Microsoft's support documentation applies the 50MB and 20-file limits to every Microsoft Copilot experience: personal accounts, work or school accounts, and free Copilot Chat. As of October 2026, Microsoft Learn documentation confirms that custom agents in Copilot Studio can ingest up to 500 files at a maximum file size of 512 MB per file for knowledge grounding.

Many guides fail to distinguish between conversational attachments (15MB in Copilot Studio agents, 50MB in Microsoft Copilot chat) and administrative knowledge base grounding (512MB), leaving users confused about why their uploads fail. When a user attempts to attach a 60MB audit report to Copilot chat, the upload does not go through. The 512MB threshold applies exclusively to administrative knowledge sources configured by makers in Copilot Studio.

The reference matrix below outlines the documented file size limits, accepted formats, and primary operating constraints across Microsoft Copilot environments:

| Interface or Platform Tier | Maximum File Size | File Count or Session Cap | Supported File Formats | Primary Constraint or Failure Mode | Date Checked |
|---|---|---|---|---|---|
| Microsoft Copilot Chat (personal, work or school, free Copilot Chat) | 50 MB per file | Up to 20 files per conversation | PDF, DOCX, XLSX, PPTX, TXT, CSV, JSON, MD, PNG, JPEG | 20-file cap requires starting a new conversation | October 2026 |
| Copilot Studio Runtime Inputs | 15 MB per file | Session memory dependent | DOCX, CSV, PDF, TXT, PNG, JPG | 40-page PDF cap; 30,000 characters per Office file without code interpreter | October 2026 |
| Copilot Studio Knowledge Base | 512 MB per file | Up to 500 files per agent | DOCX, PDF, PPTX, XLSX, TXT | 4 to 6 hour sync for SharePoint and OneDrive sources; 7 MB cap for SharePoint without M365 license | October 2026 |
| SharePoint Grounding (with M365) | 200 MB per file | Tenant Graph indexing | Word, PowerPoint, PDF, XLSX | Requires tenant graph grounding with semantic search enabled | October 2026 |
| Microsoft Security Copilot | 3 MB per file | 20 MB total across uploaded files | DOCX, MD, PDF, TXT | Small per-file ceiling for uploaded reference files | October 2026 |

When files exceed these limits, the upload is rejected, and in Copilot Studio a large PDF can fail with a "Request body too large" error.

### Why File Processing Boundaries Differ Across Microsoft Interfaces

The disparity between conversational uploads and administrative grounding stems from language model architecture. Interactive chat sessions load document text directly into active prompt memory. Every kilobyte of text consumes model tokens that compete with instructions and dialogue history. Capping attachments at 15MB to 50MB prevents prompts from exhausting working memory and keeps latency predictable.

In contrast, Copilot Studio knowledge base ingestion operates as an asynchronous background pipeline. Files are parsed, chunked, and indexed in Microsoft Dataverse. During conversational interactions, the Copilot Studio model retrieves only relevant passages, allowing knowledge base source files up to 512MB.

## What Are the Upload Limits for Microsoft Copilot Web and M365 Chat?

Microsoft Copilot web chat and Microsoft 365 Copilot represent the primary interfaces through which knowledge workers interact with documents. The rules governing these conversational surfaces reflect strict operational trade-offs between model responsiveness, document complexity, and file throughput. When users attach spreadsheets, quarterly reports, slide presentations, or code files, Copilot validates byte volume and semantic structure before accepting payloads into prompt memory.

Understanding that these limits do not change with licensing is critical for preventing failed workflows. Many teams assume an enterprise subscription removes all boundaries, only to discover the same hard limits during time-sensitive tasks. The following technical breakdown details active constraints governing conversational prompts across consumer and enterprise access.

### One Upload Limit Across Copilot Chat Experiences

Microsoft's support documentation lists the same file limits for every Microsoft Copilot experience, including personal accounts (Personal, Family, Premium, Pro), work or school accounts, and free Copilot Chat: up to 50MB per file.

While a 50MB upload limit accommodates lengthy contracts and slide decks, the file payload remains inadequate for multi-hundred-megabyte database dumps or high-resolution scanned archives.

### The Conversation Thread Ceiling and Context Loss

Beyond byte size, Microsoft imposes a strict numeric quota: users can attach up to 20 files in a single Copilot conversation. Once a conversation already holds 20 files, Copilot does not accept more.

Microsoft's documented resolution is to start a new conversation thread. However, starting a fresh conversation resets dialogue history, custom definitions, and analytical conclusions drawn from earlier documents.

### Parsing Failures in Spreadsheets, PDFs, and Code Files

Files well below physical upload ceilings can still fail during processing due to parser constraints:

* **Tabular Memory Outages**: Excel spreadsheets (.xlsx) and CSV files with tens of thousands of rows can time out during analysis.

* **Scanned and Vector-Heavy PDFs**: Dense PDFs with complex vector schematics or scanned pages without OCR text layers cause text extraction failures.

* **Code Scripts**: While individual code files rarely exceed 10MB, uploading multi-file script collections quickly exhausts the 20-file conversation limit.

### Data Handling and Retention for Uploaded Files

According to Microsoft, files you share with Copilot are stored securely for a short time, no longer than 18 months, and then automatically deleted. Microsoft states that it does not use the content of uploaded files for model training.

However, 18-month retention does not provide collaborative team storage. Uploaded files remain tied to individual user chat histories, inaccessible to colleagues working on the same project.

## How Do Copilot Studio Knowledge Sources and Runtime Attachments Differ?

Microsoft Copilot Studio allows developers and technical leads to build custom agents tailored to internal business processes. Understanding the distinct file limits governing administrative knowledge bases versus user-facing runtime conversations is essential for deploying reliable agents across production environments.

In Copilot Studio, file ingestion splits into two separate technical domains. Administrative knowledge source ingestion handles persistent reference material that grounds the agent's general intelligence, while conversational file input allows end users to attach specific documents during active dialogue. Each pathway enforces distinct size boundaries, processing engines, and failure modes that makers must evaluate during agent design. Conflating these two channels leads to misconfigured agent topics, unexpected runtime errors, and failed document analyses that degrade user experience.

### Administrative Knowledge Source Ingestion Ceilings

When configuring an agent in Copilot Studio, makers can upload reference materials directly into the agent's knowledge base. Under Microsoft's documented quotas, individual files uploaded as knowledge sources can reach up to 512 MB per file, with each custom agent supporting up to 500 uploaded files.

Files land in Microsoft Dataverse managed storage, where they are chunked and vectorized for retrieval. Administrative ingestion carries specific operating parameters:

* **Synchronization Frequency**: SharePoint and OneDrive knowledge sources resync every four to six hours.

* **SharePoint Grounding**: Connecting SharePoint without a Microsoft 365 Copilot license limits files to 7 MB, expanding to 200 MB with tenant graph grounding.

* **SharePoint Lists**: Restricted to returning data from the first 2,048 rows per query.

### Runtime User File Inputs and Character Ceilings

When developers enable conversational file uploads in Copilot Studio, end users can attach documents directly into active chat sessions.

Microsoft Learn documentation specifies that user-uploaded conversational files are restricted to a maximum size of 15 MB per file.

Conversational inputs also enforce strict structural caps:

* **Character Limits**: Without code interpreter enabled, Copilot Studio reads up to 30,000 characters of text extracted from each Office file (Word, PowerPoint, Excel) and up to 30,000 characters in total across multiple files. PDFs are processed as files, so this character limit does not apply to them.

* **The 40-Page PDF Ceiling**: For PDF documents, Microsoft enforces a hard limit of 40 pages per file.

### The Processed Content Limit and PDF Expansion

A frequent failure in Copilot Studio is the secondary processed content limit. For PDFs, the platform imposes a separate limit of approximately 30 MB for the processed content, in addition to the 15 MB raw file size limit and the 40-page cap.

When a visually complex 25-page PDF document contains dense vector diagrams or high-resolution images, its processed content can exceed the 30 MB limit in Copilot Studio runtime. The Copilot Studio runtime agent then returns a request body too large error even though the user upload is well below the 15 MB physical file limit.

### Memory Accumulation Across Conversation Turns

Files uploaded earlier in a conversation continue to count toward what the model processes, even after the agent has answered questions about them. In extended sessions with several large files, the combined content can exceed what the model can process at once.

When that happens, the agent can stop responding or return an error. Microsoft recommends adding a Clear variable values node that clears the conversation history for the current session after each file is processed, which releases the accumulated file content.

## How Do You Analyze Documents That Exceed Copilot Upload Boundaries?

When enterprise documents exceed native upload limits, engineering teams must implement preprocessing pipelines or architectural workarounds. Managing multi-hundred-page technical specifications, dense financial archives, or multi-gigabyte regulatory filings requires decoupling document ingestion from direct chat prompts.

Relying on brute-force attachments in conversational chat leads to degraded responses, frequent timeouts, and frustrated team members. By adopting structured preprocessing workflows, teams can partition massive documents, normalize complex tabular datasets, and design multi-tiered retrieval architectures that bypass native chat boundaries entirely.

Enterprise teams frequently encounter these file ceilings when analyzing complex documentation corpora. The following architectural strategies establish reliable ingestion paths for large enterprise files without sacrificing analytical depth or document completeness.

### Programmatic PDF Splitting and Extraction

For PDF documents exceeding the 15MB runtime cap or 40-page limit, client-side partitioning slices monolithic files into manageable segments.

Using Python and pypdf, developers can automatically slice large PDF documents into 35-page chunks that comply with Copilot Studio requirements:

```python
import os
from pypdf import PdfReader, PdfWriter

def split_pdf_by_pages(input_path, output_dir, max_pages=35):
    os.makedirs(output_dir, exist_ok=True)
    reader = PdfReader(input_path)
    total_pages = len(reader.pages)
    base_name = os.path.splitext(os.path.basename(input_path))[0]
    
    for start in range(0, total_pages, max_pages):
        end = min(start + max_pages, total_pages)
        writer = PdfWriter()
        for page_num in range(start, end):
            writer.add_page(reader.pages[page_num])
            
        chunk_name = f"{base_name}_part_{start // max_pages + 1:03d}.pdf"
        chunk_path = os.path.join(output_dir, chunk_name)
        with open(chunk_path, "wb") as f_out:
            writer.write(f_out)
        print(f"Generated {chunk_name} (pages {start + 1} to {end})")

# run segmentation on sample report
split_pdf_by_pages("annual_report_2026.pdf", "processed_chunks", max_pages=35)
```

Partitioning keeps each segment under the 40-page limit, though users must still upload segments sequentially and manually synthesize findings across separate answers.

### Preprocessing Tabular Data and Normalizing Spreadsheets

Spreadsheets and tabular datasets that trigger container timeouts can be normalized before upload:

* **Column Pruning**: Strip unneeded columns such as internal primary keys, redundant timestamps, and tracking hashes.

* **Pre-Aggregation**: Calculate monthly or regional summaries in SQL or Python before uploading tables to Copilot.

* **Text Normalization**: Convert dense Excel workbooks into lean, UTF-8 encoded CSV files. Removing macros and visual styles cuts file size substantially.

### The Operational Bottlenecks of Direct Attachments

Relying on direct file attachments introduces serious architectural bottlenecks:

* **Token Consumption**: Injecting document text directly into chat prompts consumes active context tokens, leaving less room for instructions.

* **Context Dilution**: When entire documents are pasted into prompt context, models struggle with needle-in-a-haystack retrieval.

* **Static Session Isolation**: Attachments added to a conversation thread are invisible to teammates, preventing collaborative review.

* **Ephemeral Availability**: Chat attachments expire after session closure.

### Why Traditional Cloud Drives Fail Agentic Teams

When direct uploads fail, teams often turn to traditional cloud storage like SharePoint, OneDrive, Box, or Dropbox. While these platforms store large files reliably for human users, they present friction for AI agents.

In traditional cloud storage, SharePoint documents face generative grounding constraints and multihour indexing intervals before content becomes retrievable. Their connectors typically list folders and return whole files rather than indexed passages, so agents spend many calls finding and reading documents.

## How Does Fastio Index Massive Corpora for Copilot and Agentic Workflows?

As document archives expand into gigabytes and terabytes, pushing entire files into model context windows becomes unsustainable. The modern pattern separates physical document storage and indexing from the language model itself, creating a shared knowledge substrate where documents remain indexed, searchable, and persistently accessible to both humans and autonomous agents.

Fastio provides an intelligent cloud workspace designed for agentic teams and human collaboration. Fastio leaves Microsoft Copilot's native upload limits exactly where they are; what it adds is an intelligent, searchable workspace for the files that do not fit into direct chat payloads. Rather than segmenting files manually or waiting hours for Dataverse re-indexing, teams consolidate their documentation into unified workspaces that connect directly to AI assistants through open standards.

### Persistent Intelligent Workspaces with Multi-Gigabyte Ingestion

Fastio workspaces provide shared, organization-owned file infrastructure with upload limits far above chat attachment caps: 25 GB per file on Starter, 50 GB on Business, and 100 GB on Enterprise. Instead of wrestling with restrictive chat attachment limits, teams can upload massive documents and media sets directly to a workspace.

Large architectural specifications, high-resolution litigation bundles, and extensive database exports can be uploaded as unified workspace assets without manual splitting or format stripping. Every file remains persistently stored and accessible to authorized team members and connected agents.

### Universal Cloud Sync and Direct URL Ingestion

Consolidating documents into Fastio does not require downloading files to local machines. With cloud import, teams can ingest folders directly from Google Drive, Dropbox, Box, and OneDrive via OAuth, or pull public web files directly using URL import without consuming local bandwidth.

For ongoing synchronization, Cloud Sync connects Google Drive, Dropbox, Box and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. When an engineering team updates specifications in OneDrive or legal teams file contracts in Box, scheduled Cloud Sync pulls those changes into the Fastio workspace automatically.

### Hybrid Search and Intelligence Mode

Once files land in a Fastio workspace, Intelligence Mode indexes the content automatically without requiring external vector databases or chunking pipelines.

Fastio provides hybrid search, combining full-text keyword matching, semantic vector search, and search-by-metadata-value across documents, code repositories, spreadsheets, and PDFs. When an AI agent queries the workspace, hybrid search retrieves the exact relevant excerpts along with page numbers and document citations, delivering grounded context in a small fraction of the tokens a full-document upload would use.

### Structured Document Extraction with Metadata Views

Extracting specific data points across hundreds of documents through chat prompts consumes immense context and risks hallucination. Fastio solves this with [Metadata Views](/product/document-data-extraction/).

Metadata Views transform workspace document collections into a structured, queryable database:

* **Natural Language Schemas**: Define extraction fields in plain English, such as contract termination dates, invoice amounts, or liability caps.

* **Automated Typing**: Generates typed schemas supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time fields.

* **Broad Format Compatibility**: Operates across PDFs, scanned records, Word files, spreadsheets, and slide decks.

* **Programmatic Access via MCP**: AI agents can query structured records directly, bypassing document reading entirely.

### Connecting AI Assistants via Fastio MCP Server

Autonomous agents and AI assistants connect to Fastio workspaces through the remote Model Context Protocol server. The Fastio MCP server runs over Streamable HTTP, eliminating local daemon management or complex package installations.

Agents connect using dedicated Streamable HTTP endpoints designed for their specific client runtime:

* **Coding Agents**: IDE agents such as VS Code Copilot agent mode, Cursor, Claude Code, and Cline connect to `https://mcp.fast.io/mcp/code`.
* **General Assistants**: Claude desktop and web apps, Hermes Agent, and custom orchestrators connect to `https://mcp.fast.io/mcp/tools`.
* **ChatGPT and Codex**: Connect via the Fastio plugin in the ChatGPT plugin directory, or through `https://mcp.fast.io/mcp/operations` as a custom MCP server.

To connect VS Code or Copilot agent mode, configure `.vscode/mcp.json`:

```json
{
  "servers": {
    "fast-io": {
      "type": "http",
      "url": "https://mcp.fast.io/mcp/code"
    }
  }
}
```

When an agent needs information from an extensive document library, it calls Fastio MCP search tools. The workspace searches indexed files and returns cited text passages directly to the agent. Setup steps for human administrators are available at [mcp.fast.io/docs](https://mcp.fast.io/docs), and agent instructions can be referenced at [mcp.fast.io/skill.md](https://mcp.fast.io/skill.md) or [fast.io/llms.txt](https://fast.io/llms.txt).

### Team Governance, Version History, and Plans

Fastio combines autonomous agent capabilities with enterprise governance:

* **Per-File Version History**: Every file edit, replacement, or agent write is tracked in full version history. Prior revisions remain recoverable at any time.

* **Detailed Activity Log**: A detailed activity log records every change across an organization, tracking uploads, edits, moves, deletions, and permission changes by people and agents alike.

* **Role-Based Permissions**: Permissions are assigned cleanly at the organization, workspace, and share levels, so agents reach only designated workspaces.

* **Scalable Workspace Plans**: Fastio plans are structured for collaborative teams and autonomous agents:

| Plan Tier | Monthly Billing | Included Seats | Included Storage | Included Workspaces | Monthly AI Credits | Maximum Upload Size |
|---|---|---|---|---|---|---|
| Starter | $9.99/mo | 3 seats | 250 GB | 5 workspaces | 100,000 credits | 25 GB per file |
| Business | $49.99/mo | 10 seats | 5 TB | 50 workspaces | 600,000 credits | 50 GB per file |
| Enterprise | $199.99/mo | 30 seats included | 25 TB | 200 workspaces | 3,000,000 credits | 100 GB per file |

Monthly plans start with a 14-day free trial that requires a credit card. Review complete details on the [Fastio Pricing page](/pricing/) and explore technical agent workflows at [Fastio Storage for Agents](/storage-for-agents/).

## Frequently asked questions

### What is the file size limit for Microsoft Copilot?

The file size limit for Microsoft Copilot depends on the interface. Microsoft Copilot chat accepts files up to 50MB each, with a limit of 20 files per conversation, across personal accounts, work or school accounts, and free Copilot Chat. In Microsoft Copilot Studio, runtime conversational user inputs are capped at 15MB per file, while administrative knowledge base uploads support files up to 512MB.

### Can I upload large files to Copilot Studio?

Yes, but only through administrative knowledge base ingestion. Makers and administrators can upload files up to 512 MB each into an agent knowledge base, supporting up to 500 files per agent. In contrast, runtime chat attachments sent by end users to a Copilot Studio agent are restricted to 15 MB per file and 40 pages for PDF documents.

### How do I analyze documents larger than Copilot's upload limits?

To analyze documents larger than 50MB in Copilot chat or 15MB in a Copilot Studio agent, you can split large files into smaller segments using scripts like pypdf, upload them into a Copilot Studio knowledge base if you have maker permissions (up to 512MB), or store the corpus in an external intelligent workspace like Fastio. Connecting your assistant to Fastio via the Model Context Protocol allows the agent to search multi-gigabyte indexed archives dynamically without attaching full files to chat.

### Why does Copilot return a "Request body too large" error on a small PDF?

Copilot Studio enforces an internal limit of approximately 30 MB for processed document content, separate from the 15 MB physical file size limit and 40-page ceiling. When a PDF contains dense vector drawings, high-resolution scans, or complex embedded graphics, the extracted text and image data expand rapidly during parsing. If the processed document content exceeds the 30 MB runtime payload limit in Copilot Studio, the system rejects the file with a request body too large error.

### What is the difference between Copilot chat file upload and knowledge source ingestion?

Copilot chat file upload is an ephemeral, conversational feature where files (up to 50MB in Microsoft Copilot chat or 15MB in a Copilot Studio agent) are loaded into working prompt memory for immediate analysis. Knowledge source ingestion is an administrative background process where files up to 512MB are permanently parsed, vectorized, and stored in Dataverse to ground future agent responses.

### How does Fastio handle documents that exceed Copilot upload limits?

Fastio provides persistent cloud workspaces designed for multi-gigabyte files. Workspace storage accommodates large archives across Starter, Business, and Enterprise tiers without requiring manual file splitting. Enabling Intelligence Mode automatically indexes files for hybrid full-text and semantic search. AI assistants connect via remote Streamable HTTP MCP endpoints to query relevant excerpts with citations, eliminating the need to attach massive files directly to chat.

## Sources

- [Microsoft Learn: Quotas and limits in Microsoft Copilot Studio](https://learn.microsoft.com/en-us/microsoft-copilot-studio/requirements-quotas): Microsoft Copilot Studio quotas and limits allow makers to perform administrative knowledge base file upload tasks up to 512 MB per file for up to 500 files, enabling generative answers across unstructured data sources.
- [Microsoft Learn: Allow file input from users in Copilot Studio](https://learn.microsoft.com/en-us/microsoft-copilot-studio/image-input-analysis): Copilot Studio restricts files users upload during a conversation to 15 MB per file, with a 40-page PDF ceiling and a separate limit of about 30 MB for processed PDF content.
- [Microsoft Support: File upload in Microsoft Copilot](https://support.microsoft.com/en-us/microsoft-365-copilot/file-upload-in-microsoft-copilot): Microsoft Copilot accepts up to 20 files in a single conversation and up to 50 MB per file, across personal accounts, work or school accounts, and free Copilot Chat.

## 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.