---
title: "How to Export Data from Google Docs: API Limits, Methods & Portability"
slug: how-to-export-data-from-google-docs-api-limits-methods-portability
date: 2026-09-10
author: Abdul Aleem
categories: [Google Docs]
excerpt: "Learn every method to export data from Google Docs — Drive API, Docs API, Takeout, Apps Script — with real rate limits, the 10 MB cap, and format trade-offs."
tldr: "Google Docs can be exported via the Drive API (10 MB cap, 200 quota units/export), the Docs API (structured JSON), Takeout, Apps Script, or Admin Export — each with distinct limits and fidelity trade-offs."
canonical: https://clonepartner.com/blog/how-to-export-data-from-google-docs-api-limits-methods-portability
---

# How to Export Data from Google Docs: API Limits, Methods & Portability


# How to Export Data from Google Docs: API Limits, Methods & Portability

You can export data from Google Docs in eight formats — DOCX, PDF, plain text, RTF, ODT, EPUB, HTML, and Markdown — using the Google Drive UI, the Drive API's `files.export` endpoint, the Docs API's `documents.get` method, Google Takeout, or Apps Script. Each method has different throughput limits, file-size ceilings, and fidelity trade-offs. This guide covers every viable extraction path, the real constraints you'll hit, the OAuth scopes required for each, and how to choose the right approach for your scale.

## What export formats does Google Docs support?

**Google Docs supports eight export MIME types** when converting native `.gdoc` files to downloadable formats. The following table shows every supported output:

| Format | MIME Type | Extension | Notes |
|---|---|---|---|
| Microsoft Word | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` | .docx | Best fidelity for formatted docs |
| OpenDocument | `application/vnd.oasis.opendocument.text` | .odt | LibreOffice-friendly |
| Rich Text | `application/rtf` | .rtf | Legacy compatibility |
| PDF | `application/pdf` | .pdf | Read-only, layout-preserved |
| Plain Text | `text/plain` | .txt | Strips all formatting |
| Web Page (HTML) | `application/zip` | .zip | HTML + images in a zip archive |
| EPUB | `application/epub+zip` | .epub | E-reader format |
| Markdown | `text/markdown` | .md | Added relatively recently; useful for static site generators |

Markdown support is worth noting — it's useful for [content pipelines that feed into static site generators or documentation systems](https://clonepartner.com/blog/blog/google-docs-alternatives-2026-features-migration-tco). These MIME types come from Google's official export MIME types reference.

## Required OAuth scopes by method

Every programmatic export path requires specific OAuth scopes. Requesting the wrong scope is one of the most common causes of `403 Forbidden` errors in export pipelines. Here's the complete reference:

| Method | Minimum Required Scope | Notes |
|---|---|---|
| `files.export` (Drive API) | `https://www.googleapis.com/auth/drive.readonly` | Also works with `drive.file` if app created the file |
| `files.download` (Drive API) | `https://www.googleapis.com/auth/drive.readonly` | Same as `files.export` |
| `documents.get` (Docs API) | `https://www.googleapis.com/auth/documents.readonly` | Narrower scope; cannot access Drive metadata |
| `revisions.list` (Drive API) | `https://www.googleapis.com/auth/drive.readonly` | Required to enumerate version history |
| `files.list` (Drive API) | `https://www.googleapis.com/auth/drive.readonly` | Required to enumerate Docs in a Drive |

**Important distinction:** `documents.readonly` only grants access to document content via the Docs API. It does not grant access to `files.export` or any Drive API method. If your application needs both structured JSON content and file export, you must request both `drive.readonly` and `documents.readonly` — or use `drive` (full access) if writes are also required.

For service accounts using domain-wide delegation, you must also pass the `sub` parameter to impersonate the target user. Without it, the service account can only access files it owns directly, which is almost never the intended behavior in enterprise contexts. See the service account section below for details.

## Method 1: Manual export from the Google Docs UI

The fastest way to export a single document is **File → Download** inside the Google Docs editor. You pick a format, and the browser downloads the converted file. This works for one-off exports but doesn't scale.

If you need an entire folder, right-click the folder in Google Drive and choose **Download**. Drive will zip everything and convert native Google formats to their Office equivalents (Docs → DOCX, Sheets → XLSX). Expect delays on large folders — Drive compresses on the fly and there's no progress indicator beyond the browser's download bar.

> [!WARNING]
> Manual folder downloads convert all Google Docs to .docx by default. You cannot choose PDF or Markdown from the folder-level download. For format control at scale, you need the API or Apps Script.

The browser UI can export documents that exceed the Drive API's 10 MB limit. If you need to script browser-style exports without managing OAuth, the public export URL pattern works for documents shared with appropriate permissions:

```
https://docs.google.com/document/d/{docId}/export?format=pdf
```

This URL pattern bypasses the API's `files.export` size ceiling, making it a useful escape hatch for oversized documents when user session credentials are available.

## Method 2: Google Drive API `files.export`

**The `files.export` endpoint on the Drive API v3 is the programmatic standard for exporting Google Workspace documents.** It accepts a file ID and a target MIME type, then returns the converted content as bytes.

```bash
GET https://www.googleapis.com/drive/v3/files/{fileId}/export?mimeType=application/pdf
Authorization: Bearer {access_token}
```

### The 10 MB export size limit

The single hardest constraint to work around: the Drive API's `files.export` method caps exported content at **10 MB**. Google's official documentation states that "the exported content is limited to 10 MB." If your document exceeds this after conversion, the API returns a `403 exportSizeLimitExceeded` error.

The limit applies to the *output* file size, not the source document's storage footprint in Google's systems. This distinction matters: Google Docs are stored in a proprietary format that doesn't map directly to file size. A document that appears compact in the editor can produce a large DOCX or PDF if it contains many embedded images.

**Why the limit exists:** The 10 MB ceiling is an output conversion buffer constraint, not a billing or quota unit limit. When `files.export` converts a Google Doc, it performs an in-memory format conversion. The limit reflects the maximum size of the conversion output that the synchronous API endpoint will hold and return. This is why the workaround is the asynchronous `files.download` method, which offloads the conversion to a long-running operation rather than returning bytes inline.

### Estimating whether your document will hit the limit

There is no pre-export size check, so you need heuristics:

- **Images are the primary driver.** Each embedded image in a Google Doc is stored at original upload resolution. A document with 20+ high-resolution screenshots will almost certainly exceed 10 MB as PDF or DOCX.
- **PDF is typically larger than DOCX** for image-heavy documents because PDF embeds rasterized page layouts. DOCX compresses image data differently and often produces smaller output.
- **Plain text and Markdown are effectively immune.** `text/plain` and `text/markdown` strip all images and produce output an order of magnitude smaller than binary formats.
- **Practical threshold:** Documents under 20 pages with minimal images rarely hit the limit. Documents with 10+ embedded images or 50+ pages in PDF format frequently do.

**Workarounds for large documents, in order of preference:**

1. **Use `files.download`** (Drive API v3) — This method returns a long-running operation (LRO) instead of inline bytes. It's designed for larger content and does not enforce the 10 MB ceiling. Described in detail below.
2. **Export as `text/plain` or `text/markdown`** — Dramatically smaller output; images are omitted.
3. **Use the browser export URL pattern** — Works outside the API's size constraints.
4. **Strip images via the Docs API first** — Use `documents.get` to identify inline object references, remove or replace them, then export.
5. **Split the document** — Break large documents into smaller sections and export individually.

### `files.download` LRO mechanics

`files.download` is the correct long-term replacement for large document exports. Unlike `files.export`, it initiates an asynchronous conversion and returns an operation ID you poll for completion.

```python
# Step 1: Initiate the download/export operation
response = drive_service.files().download(
    fileId='YOUR_DOC_ID',
    mimeType='application/pdf'
).execute()

operation_name = response['name']  # e.g., "operations/abc123"

# Step 2: Poll until complete
import time

operations_service = build('drive', 'v3', credentials=creds)
while True:
    op = drive_service.operations().get(name=operation_name).execute()
    if op.get('done'):
        if 'error' in op:
            raise Exception(f"Export failed: {op['error']}")
        # op['response'] contains the download URI or inline content
        download_uri = op['response'].get('downloadUri')
        break
    time.sleep(2)  # Poll every 2 seconds; back off for large docs
```

The LRO response, once `done: true`, contains a `downloadUri` pointing to the converted file in temporary storage. This URI is time-limited (typically valid for a short window after generation). Common errors from this endpoint include `RESOURCE_EXHAUSTED` when the conversion itself is too large for the backend, and `DEADLINE_EXCEEDED` for extremely large documents. In practice, `files.download` handles documents that produce output up to several hundred MB.

### Drive API quota limits for exports

The Google Drive API measures usage in **quota units** rather than raw request counts. Each `files.export` call costs 200 quota units per request.

The enforced limits are:

| Limit | Value |
|---|---|
| Per minute per project | 1,000,000 quota units |
| Per minute per user per project | 325,000 quota units |
| Per day per project (egress) | 1 TB |
| Daily billing threshold | 400,000,000 quota units |

At 200 quota units per export, a single project can fire roughly **5,000 exports per minute** before hitting the project-level cap, or about **1,625 per minute per user**. The 1 TB daily egress limit is the practical ceiling for large-scale extraction jobs.

**Service account quota trap:** If you use a single service account without domain-wide delegation or user impersonation, all requests count against that one "user" — meaning you'll hit the 325,000 per-user-per-minute cap (1,625 exports/minute) long before the 1,000,000 per-project cap (5,000 exports/minute). To distribute load across the per-user quota, impersonate multiple users via the `sub` parameter during token creation. Each impersonated user gets their own 325,000 unit bucket.

If you exceed limits, the API returns `403` or `429` errors. The official guidance is to implement exponential backoff with jitter.

### Drive API error reference

| Error | HTTP Code | Subtype | Common Cause | Fix |
|---|---|---|---|---|
| Export size exceeded | 403 | `exportSizeLimitExceeded` | Output > 10 MB | Use `files.download` or lighter format |
| Forbidden | 403 | `forbidden` | Insufficient OAuth scope or sharing permissions | Check scopes; verify file access |
| Not found | 404 | `notFound` | Invalid file ID or file deleted | Verify file ID; check trash |
| Rate limit | 429 | `rateLimitExceeded` | Quota units exhausted | Exponential backoff |
| User rate limit | 403 | `userRateLimitExceeded` | Per-user quota exceeded | Impersonate additional users or reduce concurrency |
| Backend error | 503 | `backendError` | Transient Google infrastructure error | Retry with backoff |
| Quota exceeded | 403 | `quotaExceeded` | Daily project quota exhausted | Wait until reset or request increase |

## Method 3: Full Drive enumeration + batch export pipeline

In practice, bulk export requires two steps: enumerating all Google Docs in a Drive, then exporting each. Here's the complete pipeline:

```python
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
import time

def enumerate_all_docs(drive_service):
    """Returns list of all Google Docs file IDs and names in the Drive."""
    docs = []
    page_token = None
    
    while True:
        response = drive_service.files().list(
            q="mimeType='application/vnd.google-apps.document' and trashed=false",
            fields="nextPageToken, files(id, name, modifiedTime)",
            pageSize=1000,
            pageToken=page_token
        ).execute()
        
        docs.extend(response.get('files', []))
        page_token = response.get('nextPageToken')
        if not page_token:
            break
    
    return docs

def export_doc_with_retry(drive_service, file_id, mime_type, max_retries=5):
    """Exports a single doc with exponential backoff."""
    for attempt in range(max_retries):
        try:
            return drive_service.files().export(
                fileId=file_id,
                mimeType=mime_type
            ).execute()
        except HttpError as e:
            if e.resp.status == 403 and 'exportSizeLimitExceeded' in str(e):
                # Fall back to plain text for oversized docs
                return drive_service.files().export(
                    fileId=file_id,
                    mimeType='text/plain'
                ).execute()
            elif e.resp.status in (429, 503):
                wait = min(32, 2 ** attempt)
                time.sleep(wait)
            else:
                raise
    raise Exception(f"Max retries exceeded for file {file_id}")
```

The `files.list` query supports filtering by `modifiedTime > '2024-01-01T00:00:00Z'` for incremental exports — only fetch documents modified since the last run.

## Method 4: Google Docs API `documents.get` for structured content

**The Google Docs API returns a document's full content as structured JSON**, including paragraphs, text runs, tables, inline images (as references), headers, footers, and formatting metadata. This is the right choice when you need to parse or transform document content programmatically — not just dump it to a file.

```python
from googleapiclient.discovery import build

service = build('docs', 'v1', credentials=creds)
doc = service.documents().get(
    documentId='YOUR_DOC_ID',
    includeTabsContent=True
).execute()
```

The response is a deeply nested JSON object with the hierarchy: `Body → StructuralElement → Paragraph → ParagraphElement → TextRun`. Extracting text means traversing this tree, processing tables, and handling inline objects. Google provides an official sample for this traversal.

### Docs API rate limits

| Quota | Limit |
|---|---|
| Read requests per minute per project | 3,000 |
| Read requests per minute per user | 300 |
| Write requests per minute per project | 600 |
| Write requests per minute per user | 60 |

These are request counts, not quota units. At 300 reads per user per minute, you can process 300 documents per minute per authenticated user — or 3,000 per minute across all users in a project. Same service account impersonation strategy applies: impersonate multiple users to multiply your effective read throughput.

> [!NOTE]
> The Docs API does **not** export files to DOCX, PDF, or other binary formats. It only returns JSON. For file conversion, you still need the Drive API's `files.export`. Use the Docs API when you need the document's internal structure — for content analysis, migration mapping, or feeding into a different system's data model.

### What the Docs API captures that `files.export` doesn't

- **Suggestion mode content** — accepted, rejected, and pending suggestions with author metadata
- **Named ranges and bookmarks** — structured references within the doc
- **Inline object metadata** — image dimensions, crop info, and source URIs
- **Tab content** — multi-tab documents (via `includeTabsContent=True`)
- **Paragraph styling details** — named styles, indentation, spacing as granular JSON

This matters for migrations where you need to reconstruct documents in a target system with high fidelity, not just dump flat files.

### Comment export fidelity by method

| Method | Top-level comments | Threaded replies | Resolved comments | Suggestion metadata |
|---|---|---|---|---|
| DOCX (`files.export`) | ✓ Preserved | ✓ Preserved | ✓ Included | ✗ Not included |
| PDF (`files.export`) | ✗ Stripped | ✗ Stripped | ✗ Stripped | ✗ Not included |
| Plain text | ✗ Stripped | ✗ Stripped | ✗ Stripped | ✗ Not included |
| Docs API JSON | ✗ Not in `documents.get` | ✗ Not in `documents.get` | ✗ Not in `documents.get` | ✓ Full metadata |
| Drive API `comments.list` | ✓ Full | ✓ Full | ✓ Configurable | ✗ Separate resource |

**Note:** Comments are not part of the `documents.get` response body. To export comments programmatically with full thread fidelity, use the Drive API's `comments.list` endpoint with `fields=comments(id,content,replies,resolved,author)`. This is a separate call from document content export.

## Method 5: Exporting revision history

`documents.get` returns only the current document state. To access previous versions, use the Drive API's `revisions` resource.

```python
# List all revisions
revisions = drive_service.revisions().list(
    fileId='YOUR_DOC_ID',
    fields='revisions(id,modifiedTime,lastModifyingUser)'
).execute()

# Export a specific revision (not all formats are available for all revisions)
# Note: Only the most recent revision can be exported via files.export
# Older revisions require the revision's exportLinks
for rev in revisions.get('revisions', []):
    export_links = rev.get('exportLinks', {})
    pdf_link = export_links.get('application/pdf')
    # pdf_link is a direct download URL for that revision as PDF
```

**Revision export constraints:**
- `revisions.list` requires `drive.readonly` or `drive` scope
- The `exportLinks` field is only populated for Google Workspace file types, not blob files
- Google retains a limited number of auto-saved revisions; named versions (created via File → Version history → Name current version) are retained indefinitely
- You cannot export an arbitrary revision via `files.export` by ID; the `exportLinks` in the revision resource are the only programmatic access point for historical versions

## Method 6: Google Takeout for personal bulk export

**Google Takeout** is Google's self-service data portability tool that exports your entire Drive (including Docs) in one batch. It converts native Google formats to their Office equivalents and packages everything into zip or tgz archives.

### How Takeout works

1. Go to [takeout.google.com](https://takeout.google.com)
2. Select "Drive" (deselect everything else if you only want documents)
3. Choose delivery method, archive format (.zip or .tgz), and max archive size (up to 50 GB per archive file)
4. Click "Create export"
5. Wait for the email with download links

### Takeout limitations

- **No selective file export** — Takeout exports your entire Drive; you cannot pick specific folders or files
- **Sharing and permissions are stripped** — exported files lose all sharing settings and collaborator access
- **Shared-with-me files are excluded** — only files owned by you and stored in your Drive are included
- **Archive frequency is limited** — you can only create 2 to 3 archives per day
- **Download links expire** — you must download the export within one week of completion
- **Image quality may degrade** — Google's own help documentation warns that downloaded images might be lower quality
- **Large exports can fail silently** — network drops on multi-GB downloads are common and fatal; there's no resume capability
- **No incremental export** — every Takeout run is a full dump; there's no delta or changed-files-only mode

Takeout is designed for personal data portability, not enterprise migration. It's a one-way dump with no error handling, no incremental sync, and no API access.

## Method 7: Google Workspace Admin Data Export

For organizations on Google Workspace, **the Admin Data Export tool** allows super administrators to export all user-generated content across the domain — including every Google Doc.

The tool lives in the Admin console under **Security → Data access and control → Data export** (or **Data → Compliance → Data Export** in some console versions).

### Admin Export constraints

- Only super admins can initiate an export; the admin account must be at least 30 days old
- 2-Step Verification must be enabled for the initiating admin
- Full-domain exports can only run once every 30 days (for applicable editions)
- Organizations with more than 1,000 users must contact Google support to temporarily enable the tool
- The export is available no earlier than 48 hours after initiation — an intentional security delay
- Exported data lands in a Google Cloud Storage bucket and is permanently deleted 60 days after creation
- The process can take up to 9 days depending on domain size

Google Workspace Enterprise Plus, Education Standard, Education Plus, and Teaching and Learning Upgrade editions have additional options: export by organizational unit, by group, or for specific individual users.

> [!TIP]
> Exported data from the Admin tool **cannot be bulk-imported back into another Google Workspace domain**. It's a one-way extraction. If your goal is domain-to-domain migration, you'll need the Drive API or a migration service.

## Method 8: Google Apps Script for batch automation

**Google Apps Script** sits inside the Google Workspace ecosystem and can programmatically export documents using the Drive API without managing OAuth flows externally. It's ideal for scheduled or triggered export jobs within an organization.

A basic Apps Script to export a folder of Google Docs as PDFs:

```javascript
function exportDocsToPdf() {
  const folderId = 'YOUR_FOLDER_ID';
  const outputFolderId = 'YOUR_OUTPUT_FOLDER_ID';
  const folder = DriveApp.getFolderById(folderId);
  const outputFolder = DriveApp.getFolderById(outputFolderId);
  const docs = folder.getFilesByType(MimeType.GOOGLE_DOCS);

  while (docs.hasNext()) {
    const file = docs.next();
    const blob = file.getAs('application/pdf');
    blob.setName(file.getName() + '.pdf');
    outputFolder.createFile(blob);
  }
}
```

Apps Script has its own execution limits: scripts time out after **6 minutes** for consumer accounts or **30 minutes** for Workspace accounts. For large jobs, split the work across multiple triggered runs using `PropertiesService` to track the last-processed file ID.

For higher throughput, batch requests via `UrlFetchApp` can process up to 100 Drive API calls in a single HTTP request:

```javascript
function batchExportDocs(fileIds) {
  const boundary = 'batch_boundary';
  const accessToken = ScriptApp.getOAuthToken();
  
  let batchBody = '';
  fileIds.forEach((id, index) => {
    batchBody += `--${boundary}\r\n`;
    batchBody += `Content-Type: application/http\r\n`;
    batchBody += `Content-ID: <item${index}>\r\n\r\n`;
    batchBody += `GET /drive/v3/files/${id}/export?mimeType=application%2Fpdf HTTP/1.1\r\n\r\n`;
  });
  batchBody += `--${boundary}--`;
  
  const response = UrlFetchApp.fetch('https://www.googleapis.com/batch/drive/v3', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': `multipart/mixed; boundary=${boundary}`
    },
    payload: batchBody
  });
  
  return response;
}
```

Each sub-request within a batch still consumes its own quota units (200 per export), but round-trip overhead drops significantly. One well-documented implementation exports 100 Google Documents to PDF in approximately 150 seconds using this approach.

## Service accounts and domain-wide delegation

Service accounts are the standard authentication mechanism for server-side export pipelines in Google Workspace environments. The key behaviors to understand:

**Without domain-wide delegation:** A service account can only access files it owns directly (files it created) or files explicitly shared with it by a user. This is almost never sufficient for bulk export of a Workspace domain.

**With domain-wide delegation:** The service account is granted permission to impersonate users in the domain. To impersonate a user, you pass the `sub` claim in the JWT used to generate the access token:

```python
from google.oauth2 import service_account

SCOPES = [
    'https://www.googleapis.com/auth/drive.readonly',
    'https://www.googleapis.com/auth/documents.readonly'
]

def get_credentials_for_user(user_email, service_account_file):
    credentials = service_account.Credentials.from_service_account_file(
        service_account_file,
        scopes=SCOPES
    )
    # Impersonate the target user
    delegated_credentials = credentials.with_subject(user_email)
    return delegated_credentials
```

**Quota implications of impersonation:** Each impersonated user gets their own per-user quota bucket (325,000 quota units/minute for Drive API). If you're exporting files owned by 10 different users, impersonate each user when accessing their files — you'll have 10× the per-user quota available. All requests still count toward the shared per-project cap (1,000,000 quota units/minute).

**Domain-wide delegation setup requires:**
1. Creating a service account in Google Cloud Console
2. Enabling domain-wide delegation on the service account
3. Granting the service account's client ID access to the required OAuth scopes in the Workspace Admin console (Security → API Controls → Domain-wide Delegation)

Without step 3 completed by a Workspace super admin, impersonation attempts return `403 Forbidden` with no further explanation — a common debugging dead end.

## Choosing the right export method

| Scenario | Best method | Why |
|---|---|---|
| Single doc, one-off | Drive UI (File → Download) | Zero setup |
| Bulk export, 10–500 docs | Apps Script with batch requests | Runs inside Workspace, no infra needed |
| Bulk export, 500+ docs | Drive API with custom script | Full control over rate limiting and retries |
| Content parsing or transformation | Docs API (`documents.get`) | Returns structured JSON |
| Full personal Drive backup | Google Takeout | Simplest for individual users |
| Org-wide compliance export | Admin Data Export | Only option for domain-level extraction |
| Migration to another platform | Drive API + Docs API | Combine metadata, structure, and file export |
| Large docs (> 10 MB output) | `files.download` LRO | Bypasses `files.export` size ceiling |
| Version history export | Drive API `revisions.list` + `exportLinks` | Only programmatic access to historical versions |
| Comment export with full threads | Drive API `comments.list` | `documents.get` doesn't include comments |

## What gets lost in export

[No export method preserves everything](https://clonepartner.com/blog/blog/csv-saas-data-migration). Here's what typically drops:

- **Comments and suggestions** — DOCX export preserves comments and threaded replies; PDF and plain text do not. Resolved comments are included in DOCX. Suggestion metadata (author, timestamp) requires the Docs API JSON. Use `comments.list` for full programmatic comment access.
- **Sharing permissions** — Every export method strips sharing settings. Google Takeout explicitly does not maintain permissions.
- **Version history** — No export format carries revision history. The Drive API's `revisions.list` + `exportLinks` retrieves historical versions separately, but the number of auto-saved revisions Google retains is limited.
- **Linked Chips and Smart Chips** — These Google-native objects (people mentions, dates, file links) degrade to plain text or disappear entirely in non-Google formats.
- **Embedded drawings** — Native Google Drawings embedded in Docs rasterize to images during conversion; the editable drawing data is not preserved in any export format.
- **Document tabs** — Multi-tab documents (a newer Docs feature) require `includeTabsContent=True` in the Docs API call; `files.export` to DOCX may merge or flatten tab structure.
- **Named styles and theme data** — Custom document themes do not transfer to DOCX or ODT with full fidelity.

## Rate limiting and error handling best practices

When building export pipelines at scale:

- **Implement exponential backoff with jitter.** Both the Drive and Docs APIs return `429` errors under load. Start with a 1-second wait, double after each failure, cap at 32–64 seconds, and add ±25% random jitter to prevent thundering herd across parallel workers.
- **Use per-user parallelism deliberately.** Impersonate multiple users to multiply effective quota. Track per-user quota consumption separately if running high-concurrency jobs.
- **Handle `exportSizeLimitExceeded` explicitly.** When a `files.export` returns this error, automatically retry with `text/plain` or escalate to `files.download`. Don't surface this as a fatal error.
- **Monitor quota consumption in Cloud Console.** The Quotas & System Limits page breaks down usage by method and user. Set alerting at 70% of quota to catch spikes before they become outages.
- **Batch where possible.** The Drive API supports batch requests that bundle up to 100 individual API calls into a single HTTP request. Each sub-request still consumes its own quota units, but latency and connection overhead drop significantly.
- **Use `modifiedTime` filtering for incremental runs.** The `files.list` query supports `modifiedTime > '{timestamp}'` to fetch only documents changed since your last export run. This is essential for keeping large exports current without re-processing the full corpus.

## Frequently asked questions

### What is the file size limit for Google Docs API export?

The Google Drive API files.export method limits exported content to 10 MB. If the converted output exceeds this, the API returns a 403 exportSizeLimitExceeded error. Use the files.download method or the browser-based export URL for larger documents.

### What formats can you export a Google Doc to?

Google Docs can be exported to DOCX, ODT, RTF, PDF, plain text (.txt), HTML (as a .zip), EPUB, and Markdown (.md). The available formats depend on the export method — the Drive API supports all eight MIME types.

### How many Google Drive API export requests can I make per minute?

Each export costs 200 quota units. The Drive API allows 1,000,000 quota units per minute per project and 325,000 per user, so roughly 5,000 exports per minute per project or 1,625 per user. Daily egress is capped at 1 TB.

### Does Google Takeout export shared Google Docs?

No. Google Takeout only exports files you own that are stored in your Drive. Files shared with you are excluded. Sharing permissions and collaborator access are also stripped from all exported files.

### How do I export Google Docs data for an entire organization?

Google Workspace super admins can use the Admin Data Export tool under Security → Data access and control → Data export. It exports all user content to a Cloud Storage bucket. The export takes up to 9 days, requires a 30-day-old admin account, and data is deleted after 60 days.