# Grok File Upload Limit: File Size Caps, Formats, and Workarounds The Grok file upload limit caps individual document attachments at 150MB on web chat and 48MB via the xAI Files API. Understanding these platform boundaries prevents payload errors during automated ingestion and interactive analysis. When document collections exceed single-file limits, storing files in an intelligent workspace queried through the Model Context Protocol replaces manual attachments with indexed semantic search. Source: https://fast.io/resources/grok-file-upload-limit/ Author: [Tom Langridge](https://fast.io/authors/tom-langridge/) Last reviewed: 2026-09-11 ## What Is the Grok File Upload Limit Across Web and API Interfaces? The Grok file upload limit caps individual document attachments at 150MB on the web interface, while the developer xAI Files API enforces a file size limit of 48MB per file for attachments. Many developers encounter payload errors when transitioning from ad-hoc experimentation in consumer web chat to automated programmatic workflows using xAI developer endpoints. In interactive web sessions, xAI accommodates larger files because user interactions are conversational and human-paced. In automated API pipelines, incoming payloads are strictly throttled at the network ingestion boundary to protect server throughput and manage processing queues. According to official xAI documentation, Grok web and mobile apps enforce a file upload limit of up to 150MB per file. In contrast, the developer xAI Files API enforces a file size limit of 48MB per file for attachments. This gap creates recurring friction for teams building agentic document pipelines. A file that uploads easily into a chat box fails immediately when sent through script automation. The following comparison details verified file size caps, platform boundaries, and operational scopes across xAI services: | Platform or Interface | File Size Cap | Supported Formats | Primary Use Case | Checked Date | | :--- | :--- | :--- | :--- | :--- | | Grok Web and Mobile Apps | 150MB per file | Documents, code, audio, video, images | Interactive chat and ad-hoc analysis | September 2026 | | xAI Files API (`POST /v1/files`) | 48MB per file | Text, Markdown, code, PDF, CSV, JSON | Programmatic chat attachments | September 2026 | | xAI Collections API | 100MB per file | Text, Markdown, structured documents, PDF | Vector indexing and persistent search | September 2026 | | Multimodal Vision Uploads | 20MB per image | JPEG, PNG, WebP, HEIC, BMP | Diagram and visual reasoning | September 2026 | | xAI Batch Processing API | 200MB per file | JSONL batch request files | Asynchronous offline evaluations | September 2026 | | Speech-to-Text API | 500MB per file | MP3, WAV, M4A, FLAC, AAC | Audio transcription pipelines | September 2026 | These boundaries define what the server accepts over the network connection, but payload size and model context consumption operate on separate mechanics. When you attach a file to a chat completion request, the xAI API does not dump the entire raw file into the prompt context window. Instead, the API implicitly attaches an internal document search tool. Grok executes autonomous retrieval against the file content, pulling specific passages into context dynamically. Understanding this retrieval architecture clarifies why file size alone does not determine processing success. Large files with complex formatting or dense tables consume processing time during initial parsing. For teams managing large repositories, centralizing files in dedicated [Fast.io workspaces](/product/workspaces/) and connecting them through [Fast.io for Agents](/storage-for-agents/) provides an alternative to repeatedly uploading raw files as chat attachments. ## Supported File Formats and Platform Constraints Grok processes a broad spectrum of document types, structured data sets, source code repositories, and multimodal media formats. Acceptance rules, MIME type handling, and text extraction behaviors differ depending on whether you submit files through the consumer chat interface or post multipart payloads directly to developer API endpoints. When an attachment reaches the platform, ingestion services inspect the file header and MIME classification before queuing it for processing. Plain text, source code, and structured data flow directly into the tokenization pipeline, while binary documents like PDFs and media files trigger specialized extraction workers. Understanding how xAI categorizes and processes these formats ensures developers choose the right transmission path for their workloads. xAI organizes file ingestion across several primary operational categories: ### Documents and Structured Data Types Grok accepts standard document formats including PDF, DOCX, TXT, CSV, XLSX, PPTX, HTML, XML, JSON, Markdown, LaTeX, ODT, and RTF. When a document arrives, background extraction services parse structural elements such as headings, paragraphs, and tabular grids. For PDFs, extraction accuracy depends on document construction. Text-native PDFs generated from word processors or code compilers parse quickly. Scanned documents requiring optical character recognition take longer and consume multimodal vision passes. Structured data tables in CSV and JSON formats parse into structured representations, enabling Grok to filter columns, calculate summaries, and answer aggregate numerical questions. ### Codebases, Media Containers, and Attachment Quantities Developers inspect scripts across modern languages, including Python, JavaScript, TypeScript, Go, Rust, C++, Java, SQL, HTML, CSS, YAML, and shell scripts. The model preserves indentation and syntax structures, making it practical to debug error traces or refactor functions. Audio uploads accept MP3, WAV, M4A, OGG, FLAC, and AAC containers, running speech transcription to analyze spoken dialogue. Video processing accepts MP4 and MOV containers, extracting key video frames alongside audio tracks for temporal analysis. Platform interfaces enforce specific attachment quantity limits per conversation turn. The web interface allows multiple files per prompt, subject to total browser payload stability. In the developer API, passing multiple file identifiers activates the internal search tool across all referenced files. However, query latency increases with each additional file because the model must coordinate searches across multiple distinct documents. ## Why API Uploads Fail: Common Edge Cases and Rate Limits Teams deploying Grok into automated pipelines frequently run into recurring technical failure modes. Understanding these operational bottlenecks helps engineers design resilient architectures. The four most frequent ingestion failures include: 1. The Payload Boundary Collision: Scripts pulling files from cloud buckets or internal servers often push raw binary streams directly to `POST /v1/files`. If client software lacks client-side size checks, files exceeding the limit trigger immediate HTTP client errors, breaking pipeline execution. 2. Ephemeral Lifecycles and Redundant Re-uploads: Files uploaded via the standard Files API exist primarily for immediate chat interactions. Although the API supports an optional expiration setting up to thirty days, files are not automatically organized into persistent hierarchical folders for cross-session reuse. Automated workers must repeatedly re-upload files across independent tasks, generating unnecessary network overhead. 3. Escalating Inference Overhead from Repeated Searches: Because attaching files to chat completions turns the interaction into an agentic search workflow, xAI bills for the internal tool calls required to search the document. In iterative development loops where multiple queries hit the same large manual, running repeated agentic searches against raw attachments multiplies operational costs. 4. Multi-Agent State Divergence: When multiple autonomous developer agents collaborate on a codebase or technical document, passing isolated file attachments creates fragmented state. One assistant cannot see modifications written by another assistant unless the file is manually re-uploaded and distributed. These friction points mirror the challenges developers experience across other AI ecosystems. For example, teams working within Claude Projects regularly encounter the fifty-file project boundary, prompting engineers to seek external storage layers that maintain context across independent sessions. ## How to Bypass Upload Limits Using Remote MCP Workspaces When engineering teams hit Grok file upload limits, the conventional response is splitting documents into smaller chunks or converting files into compressed plain text. This approach introduces operational toil and fragments document context. The architectural solution is decoupling file persistence from prompt payloads entirely. Instead of pushing megabytes of raw files into chat completions, teams place their complete document library inside an intelligent Fast.io workspace. Fast.io serves as an external knowledge substrate where documents remain persistent, versioned, and searchable. Once files land in a workspace, enabling [Intelligence Mode](/product/ai/) automatically indexes every document for both exact keyword matching and semantic vector retrieval. Rather than uploading files into Grok, you connect the assistant to Fast.io through the remote Model Context Protocol (MCP) server hosted at `https://mcp.fast.io/mcp`. When Grok needs information to answer a prompt, it queries Fast.io via standard MCP tools. The model retrieves only the precise paragraphs, code snippets, or data rows relevant to the user query, complete with citations pointing to the source file. This architecture provides distinct technical benefits: - Preserves Context Windows: Grok receives targeted text fragments rather than swallowing entire technical manuals, keeping prompt token consumption minimal. - Eliminates Network Ingestion Bottlenecks: Files upload once to Fast.io and remain available indefinitely without repeated transfers to AI inference endpoints. - Supports Large Repositories: Fast.io workspaces accommodate extensive document collections that far exceed single-file attachment ceilings. - Fast.io does not alter xAI's internal API limits. Instead, it bypasses the need to upload files as chat attachments by providing live retrieval over the network. ## Steps to Connect Grok to Fast.io for Semantic Document Search Connecting Grok to an intelligent workspace requires only a few minutes of setup using standard developer tooling and open protocols. By establishing a direct link between your AI assistants and persistent storage, engineering teams eliminate the friction of manual file uploads and prevent context fragmentation across separate chat sessions. This setup pairs Grok with an intelligent knowledge layer that manages document ingestion, background indexing, and version tracking automatically. Instead of passing gigabytes of raw data across transient network calls, the assistant retrieves only the precise excerpts needed to complete complex coding, analysis, or research tasks. Follow these practical steps to configure persistent document retrieval for your organization: ### Organizing Documents and Enabling Workspace Intelligence Begin by creating an organization workspace in Fast.io. You can upload large files directly using chunked uploads, or import existing folder structures from external services. Fast.io supports direct [cloud import](/product/cloud-import/) from Google Drive, Dropbox, Box, and OneDrive through secure OAuth connections. The import process transfers files cloud-to-cloud without routing data through your local machine or drawing on local network bandwidth. Once your documents reside in the workspace, turn on Intelligence Mode. The platform indexes the contents immediately. Hybrid search indexing enables full-text keyword lookups, semantic meaning-based searches, and structured metadata queries across PDFs, spreadsheets, presentations, and source code. ### Configuring the Remote Fast.io MCP Server Fast.io provides a remote MCP server accessible over Streamable HTTP at `https://mcp.fast.io/mcp`. For client environments that authenticate using API keys, configure the endpoint using standard MCP client settings: ```json { "mcpServers": { "fastio": { "url": "https://mcp.fast.io/mcp", "headers": { "Authorization": "Bearer YOUR_FASTIO_API_KEY" } } } } ``` If your environment passes credentials directly in the URL path, point your configuration to `https://mcp.fast.io/mcp/key`. With this configuration active, your developer agent or assistant can invoke search tools directly against the workspace. When a user asks a question about product architecture, contract terms, or system configurations, the assistant queries Fast.io, extracts relevant passages, and responds with accurate citations. Multiple human engineers and autonomous agents can read and write to the same workspace concurrently. Every document maintains per-file version history and an append-only audit log, ensuring complete visibility into team activity. Every organization starts with a 14-day free trial, which requires a credit card. Fast.io offers Starter, Business, and Growth plans with details on the [pricing page](/pricing/). ## Frequently asked questions ### What is the file upload limit for Grok? Grok web and mobile apps enforce a file upload limit of up to 150MB per file for standard attachments. For developers calling the xAI Files API, the platform enforces a file size limit of 48MB per file for attachments. For collections and image inputs, dedicated size ceilings apply as documented in the xAI developer specifications. ### Can you upload PDFs to Grok AI? Yes, Grok natively accepts PDF documents across both consumer web chat and developer API endpoints. When a PDF is uploaded, Grok extracts text, interprets tables, and analyzes embedded diagrams using multimodal vision. For developer chat completions, attaching a PDF automatically triggers xAI's internal attachment search tool to query relevant sections. ### What file formats does Grok support? Grok supports standard text documents (PDF, DOCX, TXT, RTF, ODT), structured datasets (CSV, XLSX, JSON, XML), presentations (PPTX), code scripts (Python, JavaScript, TypeScript, Go, Rust, C++, Java, SQL, HTML, CSS, YAML, shell scripts), audio files (MP3, WAV, M4A, FLAC, AAC), and video containers (MP4, MOV). ### What happens when an upload exceeds the Grok file size limit? Uploading a file exceeding the maximum size limit produces an immediate error. The web interface displays a file rejection notification, while the xAI Files API returns a client error indicating the payload exceeds the accepted boundary. To process files larger than these limits, you must compress the document, split it into smaller segments, or query it remotely via an external MCP workspace. ### How can you query large document libraries in Grok without hitting upload limits? Rather than attaching raw files directly to chat messages, you can store your document library in an intelligent workspace on Fast.io and connect Grok through the remote Model Context Protocol (MCP) server. Fast.io automatically indexes documents for semantic retrieval, allowing Grok to search and retrieve specific excerpts on demand without passing entire files through prompt payloads. ## Sources - [xAI Documentation: Grok FAQ](https://docs.x.ai/grok/faq) — Grok web and mobile apps enforce a file upload limit of up to 150MB per file. - [xAI Documentation: Files Overview](https://docs.x.ai/developers/files) — The xAI Files API enforces a file size limit of 48MB per file for attachments. Editorial standards: https://fast.io/editorial-policy/ ## 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 at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.