# How to Download Files with Google Drive API: Media vs Export Methods Downloading files through the Google Drive API requires using files.get with alt=media for binary files or files.export with a target MIME type for native Google Docs. Handling both types requires inspecting item metadata, managing chunked transfers for large payloads, and respecting per-minute quota units. This guide covers Python implementations, HTTP range requests, error handling, and intelligent workspace retrieval. Source: https://fast.io/resources/google-drive-api-download-file/ Author: [Derek Labian](https://fast.io/authors/derek-labian/) Last reviewed: 2026-10-05 ## The Core Split: Binary Files vs Google Workspace Document Exports Attempting to download a native Google Doc using a standard binary files.get request with alt=media fails with an immediate HTTP 403 or 400 error, because Google Workspace documents do not store fixed byte streams on disk. Instead, Google Drive maintains two separate API architectures for file retrieval: binary downloads for blobs like PDFs and images, and an on-the-fly conversion pipeline via files.export for Docs, Sheets, and Slides. Downloading a file through the Google Drive API requires using files.get with alt=media for binary files or files.export with a target MIME type for native Google Docs. Understanding this division is essential for developers writing automation scripts, migration workers, or retrieval systems for autonomous agents. A binary file stored in Google Drive (such as an uploaded PNG image, a PDF report, an MP4 recording, or a ZIP archive) preserves its byte sequence. In contrast, Google Docs, Sheets, and Slides are hosted cloud items. They exist as dynamic internal document trees rather than static files. You cannot stream raw bytes from an item that has no raw bytes to stream. ### Inspecting Item Metadata Before Retrieval Before executing a download or export call, inspect item metadata using files.get to identify its MIME type and verify download permissions. Retrieving metadata prevents runtime failures caused by calling the wrong endpoint or encountering restricted permissions. To retrieve file metadata, construct an HTTP GET request requesting the id, name, mimeType, size, and capabilities fields: ```http GET https://www.googleapis.com/drive/v3/files/{fileId}?fields=id,name,mimeType,size,capabilities Authorization: Bearer {token} Accept: application/json ``` The response returns a JSON representation of the file resource: ```json { "id": "1A2B3C4D5E6F7G8H9I0J", "name": "Q3_Strategic_Roadmap", "mimeType": "application/vnd.google-apps.document", "capabilities": { "canDownload": true } } ``` Two fields determine how your application must handle the file: - **capabilities.canDownload:** If this boolean is false, the authenticated user does not have permission to download the file. Attempting a download returns an HTTP 403 Forbidden error. - **mimeType:** If the MIME type starts with `application/vnd.google-apps.`, the item is a native Google Workspace resource. You must use `files.export`. If the MIME type is any standard internet media type (such as `application/pdf`, `image/jpeg`, or `text/plain`), you must use `files.get` with `alt=media`. Structural items like folders (`application/vnd.google-apps.folder`) and shortcuts (`application/vnd.google-apps.shortcut`) cannot be downloaded or exported. Folders require querying the `files.list` endpoint to enumerate their contents, while shortcuts require reading the `shortcutDetails.targetId` field to access the underlying target. ### Decision Framework for Google Drive File Downloads The following matrix contrasts the retrieval pathways available across the Google Drive REST API v3: | Resource Type | Example Formats | API Method | Target HTTP Endpoint | Key Parameters | Output Format | | :--- | :--- | :--- | :--- | :--- | :--- | | **Binary Blob** | PDF, PNG, MP4, ZIP | `files.get` (or `files.get_media`) | `GET /drive/v3/files/{fileId}?alt=media` | `alt=media` | Original binary byte stream | | **Large Binary** | Datasets, disk images | `files.get` with Range header | `GET /drive/v3/files/{fileId}?alt=media` | `alt=media`, `Range` header | Sliced byte chunks via HTTP 206 | | **Google Docs** | Native text documents | `files.export` (or `files.export_media`) | `GET /drive/v3/files/{fileId}/export` | `mimeType=application/pdf` or docx | Converted document file | | **Google Sheets** | Native spreadsheets | `files.export` | `GET /drive/v3/files/{fileId}/export` | `mimeType=text/csv` or xlsx | Tabular sheet or workbook | | **Google Slides** | Native presentations | `files.export` | `GET /drive/v3/files/{fileId}/export` | `mimeType=application/pdf` or pptx | Presentation deck | | **AI Workspaces** | Multi-format team files | Fast.io Workspace via MCP | Remote MCP (`https://mcp.fast.io/mcp/tools`) | Hybrid semantic search tool call | Indexed passages with file citations | Selecting the wrong method creates immediate failures. Sending an `alt=media` request to a Google Doc returns an HTTP 403 or 400 error indicating that the requested file has no binary content. Sending an `export` request to a binary PDF returns an HTTP 403 error stating that the file cannot be exported. A reliable retrieval pipeline must evaluate the MIME type before issuing the request. ## How to Download Files with Google Drive API Using files.get and Range Requests Binary files stored in Google Drive represent static payloads uploaded by users or third-party applications. To download these assets, the Drive API provides the `files.get` endpoint with the `alt=media` system parameter. ### Simple REST Download with Python Requests For smaller binary files, a direct HTTP GET request retrieves the entire payload in a single response stream. The following Python script uses the `requests` library to stream binary content directly to local storage: ```bash pip install requests ``` ```python import requests def download_binary_file(access_token: str, file_id: str, destination_path: str) -> None: """Download a binary file from Google Drive using files.get with alt=media.""" url = f"https://www.googleapis.com/drive/v3/files/{file_id}?alt=media" headers = { "Authorization": f"Bearer {access_token}", } with requests.get(url, headers=headers, stream=True, timeout=60) as response: response.raise_for_status() with open(destination_path, "wb") as f: for chunk in response.iter_content(chunk_size=1024 * 1024): if chunk: f.write(chunk) ``` Setting `stream=True` in `requests.get` prevents reading the entire file into application memory at once. The iterator yields fixed-size byte chunks, buffering data to disk while keeping memory consumption constant regardless of file size. ### Resumable Chunked Downloads via HTTP Range Headers When downloading large datasets, video files, or archives across unstable internet connections, single-stream downloads remain vulnerable to socket resets and packet loss. If a connection drops midway through a multi-gigabyte download, a standard request aborts, discarding all transferred bytes. To build a fault-tolerant download worker, use the standard HTTP `Range` request header. Google Drive API supports partial content requests using byte ranges. When the client provides a `Range: bytes={start}-{end}` header, the Drive API returns an `HTTP 206 Partial Content` status with a `Content-Range` response header indicating the transferred range and total file size. The following Python script downloads large binary files in discrete chunks, tracking the current byte offset and resuming from the last confirmed byte if a network failure occurs: ```python import os import time import requests CHUNK_SIZE = 10 * 1024 * 1024 ### 10 MB per chunk def download_large_binary_resumable( access_token: str, file_id: str, destination_path: str, total_size: int, max_retries: int = 5, ) -> None: """Download a large binary file using chunked HTTP Range requests with retry logic.""" url = f"https://www.googleapis.com/drive/v3/files/{file_id}?alt=media" start_byte = 0 if os.path.exists(destination_path): start_byte = os.path.getsize(destination_path) if start_byte >= total_size: return while start_byte < total_size: end_byte = min(start_byte + CHUNK_SIZE - 1, total_size - 1) headers = { "Authorization": f"Bearer {access_token}", "Range": f"bytes={start_byte}-{end_byte}", } chunk_received = False for attempt in range(max_retries): try: response = requests.get(url, headers=headers, timeout=30) if response.status_code in (200, 206): with open(destination_path, "ab") as f: f.write(response.content) start_byte += len(response.content) chunk_received = True break elif response.status_code == 429: time.sleep(2 ** attempt) else: response.raise_for_status() except (requests.RequestException, IOError): if attempt == max_retries - 1: raise time.sleep(2 ** attempt) if not chunk_received: raise RuntimeError(f"Failed to retrieve chunk {start_byte}-{end_byte}") ``` ### Downloading via the Official Google API Client If your application relies on the official Google client libraries rather than raw HTTP requests, the `google-api-python-client` package provides a built-in helper class named `MediaIoBaseDownload`. To install the client library and its authentication dependencies: ```bash pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib ``` The `MediaIoBaseDownload` class encapsulates chunk tracking and byte seeking: ```python import io from googleapiclient.discovery import build from googleapiclient.http import MediaIoBaseDownload def download_with_google_client(service, file_id: str, destination_path: str) -> None: """Download a binary file using Google API Python client and MediaIoBaseDownload.""" request = service.files().get_media(fileId=file_id) with io.FileIO(destination_path, "wb") as fh: downloader = MediaIoBaseDownload(fh, request, chunksize=10 * 1024 * 1024) done = False while not done: status, done = downloader.next_chunk() if status: print(f"Download progress: {int(status.progress() * 100)}%") ``` `MediaIoBaseDownload` automatically issues `Range` queries, tracking byte intervals and writing incoming buffers directly into the provided file handle. ## How to Export Google Docs, Sheets, and Slides via files.export Google Workspace documents do not possess a fixed binary representation on disk. When an application requests a Google Doc, Sheet, or Slide, the Google Drive export service renders the internal document model into a requested target MIME type on demand. To export a Google Workspace item, issue an HTTP GET request to the `files.export` endpoint, specifying the target file ID and the desired `mimeType` query parameter: ```http GET https://www.googleapis.com/drive/v3/files/{fileId}/export?mimeType={targetMimeType} Authorization: Bearer {token} ``` ### Supported Conversion MIME Types The Google Drive export engine supports specific output formats depending on the source document type: | Google Workspace Source | Source MIME Type | Supported Export Target Formats | Target Export MIME Type Parameter | | :--- | :--- | :--- | :--- | | **Google Docs** | `application/vnd.google-apps.document` | PDF document | `application/pdf` | | | | Microsoft Word | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` | | | | Plain text | `text/plain` | | | | Rich text format | `application/rtf` | | | | Web page HTML zipped | `application/zip` | | | | EPUB publication | `application/epub+zip` | | **Google Sheets** | `application/vnd.google-apps.spreadsheet` | PDF document | `application/pdf` | | | | Microsoft Excel | `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` | | | | Comma-separated values | `text/csv` (exports first active sheet only) | | | | Tab-separated values | `text/tab-separated-values` (first sheet only) | | | | Web page HTML zipped | `application/zip` | | **Google Slides** | `application/vnd.google-apps.presentation` | PDF document | `application/pdf` | | | | Microsoft PowerPoint | `application/vnd.openxmlformats-officedocument.presentationml.presentation` | | | | Plain text outline | `text/plain` | | **Google Drawings** | `application/vnd.google-apps.drawing` | PDF document | `application/pdf` | | | | PNG raster image | `image/png` | | | | JPEG raster image | `image/jpeg` | | | | SVG vector graphic | `image/svg+xml` | When exporting Google Sheets to CSV or TSV, the API converts only the first visible worksheet tab in the workbook. If your workflow requires multi-tab spreadsheet extraction, export the file as Microsoft Excel (`xlsx`) and parse the resulting workbook locally, or use the dedicated Google Sheets API v4 to query individual sheet ranges. ### Managing Export Size Constraints A critical constraint in Google Drive document automation is the export file size limit. Exported content from Google Workspace documents is limited to 10 MB in the Google Drive API. When exported content from Google Workspace documents exceeds the 10 MB limit during conversion, the export pipeline aborts and returns an HTTP 403 Forbidden error with the reason `exportSizeLimitExceeded` or an HTTP 400 Bad Request error. This limit frequently catches developers off guard when processing large Google Sheets containing hundreds of thousands of cells or Google Docs filled with high-resolution embedded images. Because Google Docs do not report a static `size` field in metadata, you cannot predict the exact converted byte size before issuing the export request. When encountering files that exceed the export threshold, implement one of the following architectural strategies: - **Query the Native Document APIs:** Instead of exporting through the Drive API, connect directly to the Google Docs API v1 or Google Sheets API v4. These endpoints return structured JSON trees or cell value matrices without converting to external file formats. - **Export to Smaller Formats:** If a document export fails because high-resolution assets push the rendered output beyond the size ceiling, exporting as plain text or Microsoft Word format produces a smaller payload that succeeds. - **Split Workbooks:** For extensive spreadsheets, split data across multiple linked workbooks or query individual worksheet tabs. ### Unified Download and Export Python Router The following Python script provides a unified download function that inspects file metadata, branches to `files.get` or `files.export` based on MIME type, and handles common export conversions automatically: ```python import os import requests WORKSPACE_EXPORT_MAPPINGS = { "application/vnd.google-apps.document": { "mimeType": "application/pdf", "extension": ".pdf", }, "application/vnd.google-apps.spreadsheet": { "mimeType": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "extension": ".xlsx", }, "application/vnd.google-apps.presentation": { "mimeType": "application/pdf", "extension": ".pdf", }, "application/vnd.google-apps.drawing": { "mimeType": "image/png", "extension": ".png", }, } def retrieve_drive_file(access_token: str, file_id: str, output_directory: str) -> str: """Inspect metadata and route to files.get or files.export accordingly.""" headers = {"Authorization": f"Bearer {access_token}"} meta_url = f"https://www.googleapis.com/drive/v3/files/{file_id}?fields=id,name,mimeType,capabilities" meta_resp = requests.get(meta_url, headers=headers, timeout=30) meta_resp.raise_for_status() meta = meta_resp.json() mime_type = meta.get("mimeType", "") filename = meta.get("name", file_id) if not meta.get("capabilities", {}).get("canDownload", True): raise PermissionError(f"User is not permitted to download file {file_id}") if mime_type in WORKSPACE_EXPORT_MAPPINGS: export_config = WORKSPACE_EXPORT_MAPPINGS[mime_type] target_mime = export_config["mimeType"] export_url = f"https://www.googleapis.com/drive/v3/files/{file_id}/export" params = {"mimeType": target_mime} resp = requests.get(export_url, headers=headers, params=params, timeout=60) resp.raise_for_status() out_filename = filename + export_config["extension"] target_path = os.path.join(output_directory, out_filename) with open(target_path, "wb") as f: f.write(resp.content) return target_path elif mime_type.startswith("application/vnd.google-apps."): raise ValueError(f"Unsupported Google Workspace item type: {mime_type}") else: get_url = f"https://www.googleapis.com/drive/v3/files/{file_id}?alt=media" with requests.get(get_url, headers=headers, stream=True, timeout=60) as resp: resp.raise_for_status() target_path = os.path.join(output_directory, filename) with open(target_path, "wb") as f: for chunk in resp.iter_content(chunk_size=1024 * 1024): if chunk: f.write(chunk) return target_path ``` This router pattern prevents accidental errors by making the branching logic explicit. ## Managing Drive API Quotas, Rate Limits, and Error Recovery Automated download pipelines and agent retrieval workers frequently operate in high-throughput environments where hundreds of documents are indexed sequentially. In these scenarios, applications inevitably run up against Google Drive API rate limits and quotas. ### Understanding Drive API Quota Units The Google Drive API manages request volume through an abstraction called quota units rather than simple raw request counts. Google Cloud projects have specific thresholds: - **Per minute per project:** Google Drive API enforces request rate limits measured in quota units per minute per project. - **Per minute per user per project:** User rate quotas prevent any single identity from exhausting the project allowance. - **Daily project volume:** Total data transfer volume is capped per day per project to regulate bulk egress. Every API call consumes a specific number of quota units depending on the operation: - `files.get` (metadata read): 5 quota units - `files.list` (folder enumeration): 100 quota units - `files.download` (binary streaming): 200 quota units - `files.update` (metadata or content write): 50 quota units Because downloading binary files consumes 200 quota units per call, concurrent workers downloading large collections of files can rapidly draw down per-user or per-project rate limits. ### Common HTTP Error Codes and Failure Modes Production code must inspect HTTP status codes and response bodies to distinguish between permanent permission failures and transient throttling: - **HTTP 429 (Too Many Requests):** Returned when a client sends rapid bursts of requests exceeding instantaneous rate limits. - **HTTP 403 with `userRateLimitExceeded` or `rateLimitExceeded`:** Returned when the project or user exceeds the quota unit allocation. - **HTTP 403 with `cannotExportFile`:** Returned when calling `files.export` on standard binary files (such as an uploaded PDF or image). - **HTTP 403 with `exportSizeLimitExceeded`:** Returned when exporting a Google Workspace document whose converted content exceeds the 10 MB limit. - **HTTP 404 with `fileNotFound`:** Occurs when the provided `fileId` does not exist or when the application OAuth token lacks access to that item. For example, using the restrictive `drive.file` scope only grants access to files created or opened by that specific app. Downloading other files requires the `drive.readonly` or `drive` scope. - **HTTP 500, 502, 503, 504 (Server Errors):** Transient infrastructure failures across Google Cloud gateways. ### Implementing Truncated Exponential Backoff with Jitter Google API guidelines require applications encountering 429, 403 (rate limit), or 5xx errors to retry using truncated exponential backoff with randomized jitter. The following Python function demonstrates an exponential backoff decorator suitable for wrapping Drive API network operations: ```python import time import random from functools import wraps import requests def retry_with_backoff(max_retries=5, base_delay=1.0, max_delay=32.0): """Decorator that retries network operations on rate limits and server errors.""" def decorator(func): @wraps(func) def wrapper(*args, **kwargs): delay = base_delay for attempt in range(max_retries): try: return func(*args, **kwargs) except requests.HTTPError as e: status = e.response.status_code if e.response is not None else 0 is_rate_limit = False if status == 403 and e.response is not None: body = e.response.text.lower() is_rate_limit = "ratelimitexceeded" in body or "userratelimitexceeded" in body if status in (429, 500, 502, 503, 504) or is_rate_limit: if attempt == max_retries - 1: raise sleep_time = min(max_delay, delay * (2 ** attempt)) + random.uniform(0, 1) time.sleep(sleep_time) else: raise except (requests.ConnectionError, requests.Timeout): if attempt == max_retries - 1: raise sleep_time = min(max_delay, delay * (2 ** attempt)) + random.uniform(0, 1) time.sleep(sleep_time) return func(*args, **kwargs) return wrapper return decorator ``` Applying exponential backoff prevents thundering herd problems when multiple workers retry failed requests simultaneously. ## Why Intelligent Workspaces Replace File-by-File Agent Ingestion Developers and engineering teams frequently write custom Google Drive download scripts not because they want to manage local file buffers, but because autonomous agents and analytical pipelines need access to corporate knowledge. Building an in-house ingestion worker requires managing OAuth refresh tokens, tracking chunked byte ranges, converting native Docs and Sheets into readable formats, running local text extraction, and populating an external vector database. When documents change in Google Drive, the pipeline must detect modifications and re-download the affected files, repeatedly drawing down Google Drive API quota units. ### The Intelligent Workspace Approach Your team keeps their existing storage in Google Drive. Rather than developing and maintaining custom download daemons, you can import Google Drive folders into a Fast.io workspace using cloud import. (Google Drive supports cloud import today, with two-way sync coming soon; Dropbox, Box, and OneDrive document libraries currently support Cloud Sync one-way or two-way, on a schedule or on demand, never continuous, live, or real-time). ``` +-------------------------------------------------------+ | Google Drive | | (Authoritative File Store) | +---------------------------+---------------------------+ | | Cloud Import (Folder / Drive Ingestion) v +-------------------------------------------------------+ | Fast.io Workspace | | - Automatic Semantic & Hybrid Search Indexing | | - Metadata Views (Structured Schema Extraction) | | - Per-File Version History & Append-Only Audit Log | +---------------------------+---------------------------+ | | Remote MCP (Streamable HTTP) v +-------------------------------------------------------+ | Python AI Agent / Script | | - Semantic Querying via MCP Tool Calls | | - Exact Passage Retrieval with File Citations | | - Zero Local Binary File Ingestion | +---------------------------+---------------------------+ ``` ### Automatic Hybrid Indexing and Search Once documents land in a Fast.io workspace, Intelligence Mode auto-indexes every file upon arrival. The workspace builds a unified hybrid search index combining full-text keyword matching, semantic vector search, and search-by-metadata-value filtering. Autonomous AI agents connect through the remote MCP server at `https://mcp.fast.io/mcp/tools` over Streamable HTTP. Instead of downloading an entire multi-megabyte PDF or converting multi-tab spreadsheets locally, the agent executes an MCP tool call to search the workspace. The server returns exact relevant passages with source document citations, keeping agent context windows focused and eliminating local I/O overhead. ### Structured Extraction with Metadata Views Beyond semantic search, document workflows often require extracting structured operational data from spreadsheets, forms, and invoices. Fast.io provides [Metadata Views](/product/document-data-extraction/) to convert unstructured document sets into live queryable tables. Users define extraction fields in natural language, and AI designs a typed schema supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time fields. Metadata Views extract fields from PDFs, spreadsheets, presentations, and scanned forms without rigid OCR templates or manual parsing rules. Autonomous agents can create Views, trigger extractions, and query structured records directly through MCP. ### Governance, Versioning, and Performance Every Fast.io workspace provides granular permissions at the organization, workspace, folder, and file level, backed by per-file version history and a detailed activity log. When an agent finishes preparing files or configuring a workspace, ownership transfer allows the agent account to hand the organization over to human administrators while maintaining administrative access. In third-party evaluations published in the [Fastio benchmark comparison](https://fast.io/benchmarks/), Fastio was measured the fastest and the lowest cost of the providers tested. (Note that every measured row in that evaluation was that provider's native connector in Claude Cowork; no row was a local stdio server, a Files-On-Demand stub or SharePoint, and SharePoint was not measured in that test). | Architecture Factor | Direct Google Drive API Downloads | Fast.io Workspace via Remote MCP | | :--- | :--- | :--- | | **Primary Integration Point** | `https://www.googleapis.com/drive/v3/` | Remote MCP endpoint (`https://mcp.fast.io/mcp/tools`) | | **Authentication Flow** | Complex Google OAuth 2.0 with refresh tokens | API key authentication via Bearer token | | **Large File Handling** | Manual chunk calculation and HTTP Range headers | Workspace handles ingestion; agents retrieve passages | | **Native Document Handling** | Explicit `files.export` routing capped at 10 MB | Auto-indexed upon import without local format parsing | | **Search & Retrieval** | Keyword name searches and full local downloads | Hybrid search (semantic, keyword, metadata) | | **Structured Extraction** | Custom regex or external OCR extraction scripts | Native Metadata Views with typed schemas | | **Quota Overhead** | 200 quota units per download; project throttles | Hosted search queries draw zero Google Drive quota | | **Multi-Agent Access** | Concurrent downloads risk local file race conditions | Org workspaces with per-file version history | ### Strategic Implementation Recommendation Direct **Google Drive API calls** are best suited for administrative automation scripts, bulk file migrations, or desktop clients that require low-level control over binary byte streams. For **AI agents, analytical pipelines, and team document intelligence**, synchronizing files into an intelligent workspace connected via MCP eliminates download pipeline maintenance, avoids Google Drive quota limits, and delivers immediate semantic retrieval across enterprise files. ## Frequently asked questions ### How do I download a file from Google Drive using API? To download a file from Google Drive using the API, issue an HTTP GET request to https://www.googleapis.com/drive/v3/files/{fileId}?alt=media with an Authorization: Bearer {token} header. If the item is a native Google Doc, Sheet, or Slide, you must instead use the files.export endpoint with a target mimeType query parameter, such as application/pdf. ### What is the difference between files.get and files.export in Google Drive API? The files.get method retrieves file metadata or, when passed alt=media, downloads the original binary byte stream of uploaded assets like PDFs, images, and ZIP files. The files.export method converts native Google Workspace documents into requested output formats on the fly, because Google Docs, Sheets, and Slides do not have a static binary byte representation on disk. ### How do I download large files from Google Drive API in Python? To download large files reliably in Python, use the HTTP Range header to download data in sliced byte chunks, or use the MediaIoBaseDownload class from the official google-api-python-client library. Both methods prevent loading large files into memory and allow resuming interrupted transfers from the last received byte without restarting from the beginning. ### What is the file size limit for Google Docs export? Exported content from Google Workspace documents is limited to 10 MB in the Google Drive API. If exported content from Google Workspace documents exceeds the 10 MB limit during conversion, the export request fails with an HTTP 403 or 400 error. For larger datasets, developers can query the Google Docs or Google Sheets APIs directly to retrieve structured JSON content. ### How do Google Drive API quota units work for file downloads? The Google Drive API measures usage in quota units per minute per project and per minute per user. A metadata call consumes 5 quota units, listing files consumes 100 quota units, and downloading a file consumes 200 quota units. If an application exceeds these rates, Google returns HTTP 429 or 403 userRateLimitExceeded errors. ### What causes HTTP 403 cannotExportFile errors in Google Drive API? An HTTP 403 cannotExportFile error occurs when an application calls files.export on a binary file (such as an uploaded PDF, PNG, or video) rather than a native Google Workspace document. Binary files must be retrieved using files.get with alt=media instead. ### Can AI agents search Google Drive documents without downloading full files? Yes. Teams can import Google Drive folders into a Fast.io workspace, where documents are automatically indexed with hybrid semantic and keyword search. AI agents can then connect via remote MCP to query specific concepts and retrieve passages with citations, avoiding the need to download large binary files locally. ## Sources - [Google for Developers: Download and export files](https://developers.google.com/workspace/drive/api/guides/manage-downloads): Exported content from Google Workspace documents is limited to 10 MB in the Google Drive API. - [Google for Developers: Drive API limits](https://developers.google.com/workspace/drive/api/guides/limits): Google Drive API enforces request rate limits measured in quota units per minute per project. ## 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.