How to Export Data from Quip: Methods, API Limits & Migration Prep

Quip does not have a native feature to bulk export all company data. No ZIP download, no admin panel toggle, no one-click archive. If you need to get your data out of Quip at scale, you are looking at an API project.

The reason is architectural. Quip's core unit is a thread — a document, spreadsheet, or chat that carries its own message history. Documents are broken into smaller units called sections: every paragraph, list item, and table cell gets a unique section ID. And Quip folders are not traditional file system folders — they are more like tags. A single thread can exist in multiple folders simultaneously.

That model works well inside Quip. For export and migration, it means there is no clean way to dump everything into a folder tree. A usable extract requires multiple passes: discover threads, export document bodies, pull comments, and resolve folder memberships.

Here is what each export path actually gives you:

The practical takeaway: if your goal is a migration-ready extract — not just a backup — you need API-level work, and you need to plan around rate limits, missing comments, and broken Data Mentions.

Manual Document-by-Document Export via GUI

The fastest way to export a single Quip document is through the UI: Document menu → Export → choose PDF, Microsoft Word, or HTML.

This works for one-off grabs, but here is what the GUI export silently drops:

• Comments and inline annotations. Not included in any GUI export format. Retrieving comments requires a separate API call.
• Salesforce Data Mentions tied to Rich Text Fields. When exporting to Word, Data Mentions render as blank spaces. In exported PDFs and spreadsheets, they appear as empty cells.
• Spreadsheet charts. Charts in spreadsheets are excluded from the exported PDF.
• Live Apps. Salesforce Record, Salesforce List, Kanban, Calendar, and Project Tracker live apps are not exported with standard GUI exports. The Export Live App API exists but must be called separately.
• Folder hierarchy. You get a flat file. No folder path metadata is preserved.
• Custom fonts. If a document uses fonts like Manuscript or Marseilles, the PDF export can result in incorrect rendering or broken formatting.

The Folder-Level Bulk Select Trick

Quip offers a folder-level bulk select: go to the folder, select all documents, then choose "Export" from the Item menu. Your downloads begin instantly. This downloads individual files — it does not produce a structured archive. The same data-loss issues (no comments, no Data Mentions, no Live Apps) apply to each file.

For a small number of documents (under ~50), manual export is tolerable. Beyond that, it is a manual labor trap.

Using the Quip API for Bulk Exports

Quip exposes two API surfaces for export work: the Automation API (user-level) and the Admin API (site-wide). Both are needed for a complete extraction.

The Automation API is REST-based, uses OAuth 2.0 for authorization, and supports personal access tokens for individual accounts. One edge case worth knowing: generating a new personal access token invalidates the previous one.

A practical pattern is to use admin-level endpoints to discover the full universe of threads and folders, then use the Automation API's export and message endpoints to pull actual content.

Rate Limits

Rate limits are where naive scripts break. Here are the documented defaults:

Automation API (per-user):

• 50 requests per minute per personal access token
• 750 requests per hour per user

Admin API (per-admin):

• 100 requests per minute and 1,500 requests per hour

Bulk Export:

• 36,000 documents exported per hour per company

One critical detail: rate limiting returns HTTP 503 rather than the standard 429. Standard retry logic will misclassify rate-limit events as server errors unless you specifically handle 503 responses.

The Automation API returns these headers for backoff implementation:

• X-Ratelimit-Limit — requests allowed per window
• X-Ratelimit-Remaining — requests remaining
• X-Ratelimit-Reset — UTC timestamp when the limit resets

For the bulk export endpoint, the headers use a different prefix:

X-Documentbulkexport-RateLimit-Limit: 36000
X-Documentbulkexport-RateLimit-Remaining: 35999
X-Documentbulkexport-RateLimit-Reset: 1672531200
X-Documentbulkexport-Retry-After: 60

If your extraction script hits the limit and lacks automated retry logic, you end up with an incomplete dataset and no clear indicator of which documents failed.

How the Bulk Export Flow Works

The Create Bulk Export Request submits a request to asynchronously export multiple Quip documents. The call returns a request_id. Pass that request_id into the Retrieve Bulk Export Response call to get the document URL and request status for each document.

# Submit a batch export request
POST /1/threads/export/async
 
# Poll for results
GET /1/threads/export/async?request_id=...
 
# Fetch comments/messages per thread
GET /1/messages/{thread_id}?count=100&max_created_usec=...

The asynchronous pattern matters: you submit a batch, then poll for results. Depending on the size of a thread, it can take up to 10 minutes to complete the PDF export. A script that does not handle async polling will time out or return incomplete results.

Quip's bulk export also supports an include_conversations parameter for DOCX and XLSX, and the admin PDF export can append conversation history at the end of the file. This is useful for archival, but it is not the same as rebuilding inline comment placement in a target system. Treat it as history preservation, not full semantic reconstruction.

Retrieving Comments via API

Use the Get Recent Messages API method to retrieve comments from a Quip document. The endpoint returns 25 messages by default with a maximum of 100 per call.

The per-call cap is significant. If your documents have long threaded discussions, you must paginate using the max_created_usec parameter to walk backward through the full message history. Each pagination call counts against your per-user rate limit.

This also means comment extraction is not a side task — it is its own extraction pipeline. For documents with regulatory or compliance value, the comment history is often as important as the document itself.

What Breaks During a Quip Export

Every Quip export method has specific failure modes. These are the ones that matter most.

Salesforce Data Mentions Turn Blank

When exporting a Quip document to Word, Salesforce Data Mentions tied to Rich Text Fields render as blank spaces. In spreadsheet exports, they appear as empty cells. This is a known Salesforce limitation, not a bug in your export script.

Quip previously had a worse version of this issue: Data Mentions in document titles and spreadsheet cells showed up as static "Data Mention" text. That was fixed in a 2021 update — but Rich Text Field mentions in Word exports remain problematic.

If your documents are heavily integrated with Salesforce records, you need to either:

1. Resolve the Data Mentions to static values before export via the API
2. Accept the blank spaces and backfill from Salesforce data separately
3. Export as HTML and parse the mention markup programmatically

Section-Level Anchors Are Lost

Quip documents are broken into internal units called sections. Every paragraph, list item, and table cell gets a unique section ID. Comments are anchored to these specific section IDs. When you export to HTML or Word, these internal anchors are stripped. Stitching exported comments back to their exact location requires parsing the raw Quip HTML and mapping section IDs before converting the file for the target system.

Spreadsheet Charts and Formulas Break

Charts in spreadsheets are excluded from the exported PDF. Quip documents a maximum of 40,000 cells per spreadsheet PDF export. Formulas that reference live Salesforce data or cross-sheet Quip references will break on export, displaying errors or the last cached value.

If your spreadsheets contain business-critical charts, you need to screenshot or recreate them manually in the target system.

Font and Formatting Drift

Fonts sometimes look different in a PDF exported via API. Bullets may appear oversized, emojis can turn into boxes, and page breaks can land in the middle of content that should stay together. Quip switched its default typography to system fonts in a 2021 update, which means rendering varies across export targets.

Live Apps Are Not Portable

The Export Live App API can export a Salesforce live app to an HTML tag that can be turned back into a live app. Supported live apps include Salesforce Record, Salesforce List, Calendar, Kanban Board, Project Tracker, and custom live apps. But this only works if the target is another Quip environment. If you are migrating to Notion, Confluence, or SharePoint, Live Apps have no portable equivalent — you need to extract the underlying data and rebuild the widget in the target platform.

DIY Scripts vs. Professional Migration

Several open-source tools exist to automate Quip exports. Here is a realistic assessment of each.

Official: baqup (Quip's Own Sample Script)

The official Quip Automation API repository includes baqup: a Python script that exports all folders, documents, and messages to a local directory. It renders documents as HTML and includes conversations.

The catch: users report it consistently fails with 503 Over Rate Limit errors. Even with retry logic and multiplicative backoff, it cannot make it through for accounts with hundreds to thousands of documents.

quip-export (sonnenkern/quip-export)

A full automated export tool that uses the official Quip Automation API and exports all documents and folders from a Quip account.

Key limitations:

• The --comments, --embedded-images, --embedded-styles options do not work together with --docx and will be ignored. You have to choose: HTML with comments and embedded images, or DOCX without them.
• Slides are not supported. Export in PDF is not supported.

quip-mass-exporter (bmakuh)

This tool hooks into the API and allows you to export all documents at once into Markdown and HTML. It does not support DOCX or PDF, and currently only .html files are exported.

topmonks/quip-export (Quip to Notion)

This tool facilitates export of documents from Quip to both local filesystem and Notion. It can push directly into a Notion workspace via the Notion API, with optional S3 image hosting. This is the closest to a turnkey Quip-to-Notion path — but it does not handle comments, Data Mentions, or complex folder deduplication.

Browser-Based: Quip-Exporter (mindactuate)

Exports all Quip documents including images using a Personal Access Token directly in the browser. The developer built a companion rate-limit handler (patiently) specifically because the rate limit bound to a personal API token was the core challenge.

Browser-based tools lack the architecture to handle network interruptions. If a browser tab goes to sleep or the network drops during a large export, the process dies and you start over.

Common Failure Modes at Enterprise Scale

All of these tools share the same breaking points in large workspaces:

1. Rate limit exhaustion. With 50 requests/minute per token, a 10,000-document workspace can take hours just for thread listing calls — before you start downloading content.
2. No comment merging. Comments require separate API calls per document, each capped at 25–100 messages per response, each counting against rate limits.
3. No folder deduplication. Since a thread can appear in multiple folders, naive recursive crawls download the same document multiple times — or hit infinite loops from cross-referenced folders.
4. No Data Mention resolution. None of these tools resolve Salesforce Data Mentions to static values.
5. No error recovery. Most scripts lack checkpointing. A timeout at document 4,500 means starting over from zero.

For more on why simple scripts break at production scale, see The Data Migration Risk Model: Why DIY AI Scripts Fail.

Preparing Quip Data for Notion, Confluence, or SharePoint

The biggest architectural mismatch between Quip and every major target platform is folder semantics. Quip folders are tags. Notion uses nested pages. Confluence uses spaces with page trees. SharePoint uses document libraries with strict folder hierarchies.

You need a canonical folder mapping before you start any export.

Target-Specific Constraints

Notion: Notion's own import guide tells Quip users to export individual pages as Markdown or HTML and import them one by one. Notion documents a rate limit of roughly 120 file imports per 12 hours and notes that ZIP imports with 10,000+ files are likely to fail or partially import. Complex tables may degrade and often need to be handled as CSV databases instead.

Confluence: Confluence Cloud can import Word documents or HTML ZIPs. Atlassian notes that Word shapes are replaced with placeholders, unsupported images may become placeholder text, and HTML import expects a specific directory structure with .html files and same-name asset folders. Text-heavy documents work best as DOCX; layout-heavy documents work better as HTML ZIP, but you need to test unsupported elements.

SharePoint: SharePoint is less about recreating a document editor experience and more about files, metadata, permissions, and searchability. When files move between libraries with different metadata schemas, managed metadata values can be lost. Do not force Quip's multi-folder membership into a deep folder tree — pick one canonical library path and preserve extra folder memberships as columns or keywords.

If you are choosing between Notion and Confluence, see our Notion vs. Confluence (2026) Architecture Guide. For teams mapping nested page structures, our Notion to Confluence Migration Guide covers the hierarchical mapping challenges — many of the same patterns apply when your source is Quip.

A Safe Mapping Pattern for Quip's Tag-Like Folders

Based on Quip's multi-folder model and the import behavior of each target platform, this is the safest pattern we have found:

1. Choose one canonical destination path per thread. Base this on owner, business function, or the folder with the clearest long-term meaning.
2. Store every other Quip folder membership as metadata, labels, or page properties. Do not create duplicate destination pages unless the business explicitly wants duplicates.
3. Preserve original Quip identifiers. Keep thread ID, secret path, source URL, timestamps, and author metadata in your staging data. This makes QA and traceability much easier.
4. Extract comments and messages separately. Even if you use include_conversations, keep a structured message export so you are not locked into one render format.
5. Flag special content for remediation. Live apps, Salesforce Data Mentions, embedded spreadsheets, and unsupported HTML elements should go into a remediation queue — not a silent best-effort pass.
6. Map permissions deliberately. Quip threads inherit permissions from the folders they reside in. If you flatten the folder structure during migration, you risk exposing restricted HR or finance documents to the wrong audience.

Pre-Export Checklist

Before extracting anything, run through this list:

• Audit document count. Use the Admin API to get total thread counts. Under 500 documents is weekend-script territory. Over 5,000 is an engineering project.
• Identify Salesforce Data Mention usage. Search for documents with embedded mentions and flag them for separate handling.
• Tag documents by type. Quip threads can be documents, spreadsheets, slides, or chats. Your export strategy differs for each.
• Check admin export restrictions. Confirm that site-level export restrictions are not enabled.
• Identify Live App dependencies. Salesforce Record, List, Calendar, and Kanban live apps require separate extraction via the Export Live App API.
• Plan comment extraction. Decide whether historical comments need to travel with documents or can be archived separately.

For context on why data extraction is a different discipline from implementation, read Why Data Migration Isn't Implementation.

How ClonePartner Handles Quip Migrations

We have built Quip extraction pipelines for teams migrating to Notion, Confluence, SharePoint, and custom knowledge bases. Here is what we do differently from a weekend script:

• Automated backoff and retry with checkpointing. Our systems read Quip's rate limit headers and execute intelligent backoff. A failure at document 7,000 resumes at 7,001 — not from zero.
• Full comment extraction and stitching. We query the Get Recent Messages API for every document with complete pagination, appending threaded discussions to the migrated pages so historical context is preserved.
• Canonical folder resolution. We programmatically collapse Quip's tag-based folder model into a strict hierarchy for the target platform — without duplicating files and without breaking permissions.
• Salesforce Data Mention mapping. We identify embedded mentions, resolve them to static values where possible, and flag unresolvable references for manual review.

We treat Quip exports as data engineering work, not a quick scripting task. For most teams with over 1,000 documents, the combination of rate limits, comment extraction, and folder remapping makes this a multi-day project even for experienced engineers.

What to Do Next

If your Quip estate is small, use the UI and keep the project manual.

If your Quip estate is large, comment-heavy, or multi-foldered, plan an API-led export with a real staging model. That is the difference between "we downloaded some docs" and "we can prove nothing important went missing."