Coda to Quip Migration: API Limits, Export Methods & Data Mapping

There is no native migration path from Coda to Quip. Quip retired both the Upload/Import option in the Compose menu and the Import API endpoint on January 19, 2024. Salesforce has since announced the full retirement of all Quip products, with subscriptions no longer renewable after March 1, 2027. If you are migrating Coda content into Quip today, you are working against two hard constraints: a target platform with no import tool and a ticking end-of-life clock.

The only reliable method for getting structured data into Quip at scale is the Quip Automation API (POST /1/threads/new-document), which accepts HTML or Markdown and creates documents or spreadsheets programmatically. For tables, you wrap your data in HTML <table> tags. For rich-text pages, you convert Coda page content to HTML and push it as a Quip document thread.

This guide covers the real methods, the hard API constraints on both platforms, the field-mapping decisions that determine whether your migration preserves data or silently drops it, and what to expect when flattening Coda's relational model into Quip's flat spreadsheet format.

Why Migrate from Coda to Quip?

This migration direction is unusual. Most teams we talk to are moving away from Quip — see our Quip to Coda migration guide for that direction. But there are legitimate reasons teams still push content into Quip:

• Salesforce ecosystem consolidation: A corporate mandate to centralize documentation in Salesforce-adjacent tools before a larger platform shift to Slack Canvases or Agentforce.
• M&A compliance: An acquiring company runs on Quip and requires all documentation on the Salesforce stack during a transition window.
• Short-term Salesforce Live Data integration: Quip's ability to pull CRM records directly into documents outweighs the EOL risk for the next 12–18 months.

If you are evaluating whether Quip is the right long-term target for your Coda content, it almost certainly is not. Salesforce itself is recommending teams "explore how Slack and Agentforce can help with current use cases." But if the business requirement is to get content into Quip now, treat it as a short-term, high-fidelity data transfer — build the pipeline, move the data, and plan the exit.

Do not assume a 1:1 transfer. Coda exposes docs, pages, tables, formulas, and controls; Quip centers on threads, documents, spreadsheets, blobs, and folders. Plan to decompose the source, not lift and shift it.

For teams considering other targets for their Coda content, we have also written guides for Coda to SharePoint and Coda to Confluence.

The Hard Constraints: Coda and Quip API Limits

Because there is no "Move to Quip" button, any workspace of meaningful size requires an API-driven migration. Both platforms enforce strict constraints that will break naive migration scripts. Understand these before writing a line of code.

Coda API Limits

The 125 MB doc size limit catches teams off guard. On all plan types, docs at or above 125 MB (excluding attachments) are no longer accessible via the Coda API. (help.coda.io) Attachments do not count toward this limit, but large tables, formulas, and cross-doc references do. If your doc exceeds this threshold, you must split it into smaller docs before you can extract data programmatically. For more on Coda extraction mechanics, see our Coda to SharePoint migration guide.

Coda's API reads are snapshot-based, so very recent edits can lag. Send the X-Coda-Doc-Version: latest header when you need fresh-or-fail behavior.

Quip API Limits

At 50 requests/minute on the Automation API, creating 500 Quip documents takes a minimum of 10 minutes — assuming zero errors. Factor in the per-company 600 req/min ceiling (shared across all users and API types), and a multi-user migration pipeline can exhaust the budget even faster.

Migration Methods Compared

Method 1: Manual CSV & Copy-Paste (For Small Workspaces)

For workspaces with fewer than 20 documents and a handful of tables, manual migration is sometimes the fastest path. It is tedious but requires no code.

Exporting from Coda

Tables → CSV: Hover over any table in Coda, click the three-dot menu, and select Download as CSV. This exports the current view — make sure all columns are visible and all filters are removed before exporting, or you will get a partial dataset.

Pages → PDF or copy-paste: Coda lets you export entire docs or specific pages as PDF from the dropdown menu next to the doc name. PDFs preserve formatting but are not editable in Quip. For editable content, copy the page content directly and paste it into a new Quip document.

For a deeper look at all Coda export options, see our guide on exporting from Coda.

Getting Content Into Quip (Without an Import Button)

Since Quip retired the Upload/Import option in January 2024, you cannot drag-and-drop a CSV or XLSX file into Quip. Your manual options are:

1. Copy-paste from a spreadsheet app: Open the CSV in Excel or Google Sheets, select all data, copy, and paste into a new Quip spreadsheet. Quip will interpret the clipboard data as table rows.
2. Copy-paste rich text: For document pages, paste directly from Coda into a Quip document. Basic formatting (headings, bold, lists) usually survives the clipboard. Complex formatting (nested tables, embedded views, Coda formulas) will not.

What You Lose

• Relational links: Coda's cross-table lookups, relations, and formulas are reduced to static values in CSV.
• Column types: Coda's typed columns (People, Date/Time, Select List, Scale) become plain text.
• Attachments: Must be downloaded from Coda and manually uploaded to Quip threads.
• Internal links: All coda.io links become dead references.
• Page hierarchy: Coda's nested page tree is lost; you must manually recreate folder structure in Quip.

For a broader analysis of the CSV approach to SaaS migrations, see Using CSVs for SaaS Data Migrations.

Method 2: API-Driven Migration Pipeline

This is the only method that scales. The workflow has three phases: extract from Coda, transform to Quip-compatible HTML, and load via the Quip Automation API.

Phase 1: Extract from Coda

Before starting extraction, audit your workspace. Check doc sizes via Doc Settings → Doc Map. Any doc at or above 125 MB must be split before API extraction.

List all docs:

GET https://coda.io/apis/v1/docs
Authorization: Bearer {CODA_API_TOKEN}

This returns all docs accessible to the token. Paginate using nextPageToken.

List pages in a doc:

GET https://coda.io/apis/v1/docs/{docId}/pages

Returns metadata for all pages including their id, name, and hierarchy.

Export page content:

Coda's page export is async. Use POST /docs/{docId}/pages/{pageIdOrName}/export with outputFormat set to html or markdown, then poll the export status endpoint until downloadLink is ready. Use HTML when you need precise control over images, tables, and link rewriting. Use Markdown when the source pages are mostly clean text and headings.

Extract table rows:

GET https://coda.io/apis/v1/docs/{docId}/tables/{tableId}/rows?valueFormat=rich

The valueFormat=rich parameter returns data with Markdown formatting where applicable, giving you lossless access to formatted cell content. Paginate with pageToken — each response may return a partial result set.

Get column metadata:

GET https://coda.io/apis/v1/docs/{docId}/tables/{tableId}/columns

This gives you column IDs, names, and types — essential for building your field mapping. Keep a staged model keyed by stable source IDs, not just page names or row display values.

Phase 2: Transform to Quip-Compatible Format

Quip's new-document endpoint accepts either HTML or Markdown. The format parameter defaults to html.

For documents (rich text pages):

Convert Coda page HTML to clean HTML that Quip can parse. Quip's HTML support covers standard elements: <h1>–<h6>, <p>, <ul>, <ol>, <li>, <b>, <i>, <a>, <img>, <table>. Strip any Coda-specific attributes or custom elements.

For tables (spreadsheets):

Quip spreadsheets must be created with HTML <table> content. When you send more than one <tr>, the first row becomes the header row automatically:

<table>
  <tr>
    <td>Task Name</td>
    <td>Status</td>
    <td>Owner</td>
  </tr>
  <tr>
    <td>API Gateway Migration</td>
    <td>In Progress</td>
    <td>jane@example.com</td>
  </tr>
</table>

When you push this HTML payload to Quip's new-document endpoint with type=spreadsheet, Quip renders it as a native spreadsheet.

Key transformation rules:

• Flatten lookups: Replace Coda Lookup/Relation column values with their display text. Quip has no relational model.
• Resolve formulas: Export computed values, not formula expressions. Coda's formula language (thisRow, Filter(), Lookup()) has no Quip equivalent.
• Convert Select Lists: Coda's multi-select values export as comma-delimited strings. Keep them as plain text in Quip.
• Convert dates: Normalize to ISO 8601 or a consistent locale format. Coda's date objects may include timezone metadata that Quip will not parse.
• Resolve cross-doc references: Coda's Cross-doc feature lets tables pull data from other docs. These references break on export. Resolve all cross-doc values to static data before extraction.

Phase 3: Load into Quip

Create a document:

curl -X POST https://platform.quip.com/1/threads/new-document \
  -H "Authorization: Bearer {QUIP_ACCESS_TOKEN}" \
  -d "content=<h1>Page Title</h1><p>Content here...</p>" \
  -d "format=html" \
  -d "type=document" \
  -d "member_ids={FOLDER_ID}"

Create a spreadsheet:

curl -X POST https://platform.quip.com/1/threads/new-document \
  -H "Authorization: Bearer {QUIP_ACCESS_TOKEN}" \
  -d "content=<table><tr><td>Col1</td><td>Col2</td></tr><tr><td>val1</td><td>val2</td></tr></table>" \
  -d "format=html" \
  -d "type=spreadsheet" \
  -d "member_ids={FOLDER_ID}"

The member_ids parameter places the new thread in the specified Quip folder. Without it, the document lands in the authenticated user's private folder.

Appending rows to an existing spreadsheet:

For large tables that exceed what fits in a single new-document call, create the spreadsheet with headers first, then use the Edit Document endpoint to append rows:

POST https://platform.quip.com/1/threads/edit-document

Pass content as <tr><td>...</td></tr> rows, section_id as the last row's ID, and location=2 (AFTER_SECTION). You can add up to 1,000 rows per call.

Data Mapping: Coda Tables to Quip Spreadsheets

This is where migrations silently break. Coda's data model is relational and typed. Quip's spreadsheet model is flat and untyped. The guiding principle: preserve the value, preserve the source ID, and document any lost behavior in a mapping sheet.

Field Mapping Reference

Handling Unsupported and Mismatched Fields

Coda Buttons and Automations: Quip has no equivalent to Coda's button-triggered automations. Document the original button logic for manual recreation in Quip's Salesforce-integrated flows, or drop these columns.

Conditional formatting and views: Coda's table views (filtered, sorted, grouped) and conditional formatting rules do not export. Export from the base table with all columns visible.

Page metadata: Coda's API exposes authors and created/updated timestamps at the page level. Preserve those values explicitly as metadata columns or a header block in the destination if they matter for compliance, search, or editorial history. Do not rely on Quip's system fields to carry origin metadata.

Original IDs: Do not drop source Coda row and page IDs. If you ever need to re-run, diff, de-duplicate, or roll back, stable source IDs are the difference between an idempotent migration and a duplicate-content cleanup project.

Comments and discussions: Coda comments do not export through the standard table/page APIs. Scope this explicitly before go-live — decide whether to archive them separately or accept the loss.

Handling Attachments, Images, and Internal Links

Attachments are the hardest part of any Coda-to-Quip migration. Neither platform makes blob extraction easy.

Extracting Attachments from Coda

Coda's API does not have a dedicated bulk attachment download endpoint. For table-level attachments (files in Image or Attachment columns), the row data includes a URL pointing to the file. For page-level attachments (images embedded in rich text), parse the HTML content and extract src URLs.

Coda provides temporary signed URLs for attachments. These URLs expire quickly. Download all blobs immediately during extraction and store them locally or in temporary cloud storage (S3, GCS).

Uploading Blobs to Quip

Quip's API supports blob uploads via the Add Blob endpoint:

POST https://platform.quip.com/1/blob/{threadId}

Upload the file to the target Quip thread, then rewrite <img> tags in your HTML payload to reference the returned Quip blob URL before pushing the document content.

An alternative approach for batch processing: host the downloaded blobs temporarily on a publicly accessible S3 or GCS bucket, rewrite the <img src="..."> tags in your HTML to point to these temporary URLs, and push the HTML to Quip. Quip's servers will fetch the images from your temporary URLs and ingest them natively. This avoids per-thread blob uploads but adds an external dependency.

Rewriting Internal Links

All internal links pointing to coda.io/d/... URLs will be dead in Quip. Your migration script must:

1. Build a mapping table: {coda_page_id → quip_thread_id}
2. After creating all Quip documents, run a second pass to rewrite links using the Quip Edit Document endpoint
3. Replace https://coda.io/d/... hrefs with https://{your-company}.quip.com/{thread_id}

This two-pass approach is necessary because you will not know the Quip thread IDs until after document creation. Always do link rewriting after object creation, not before.

Preserving Folder Structure

Coda organizes content as docs containing nested pages. A single Coda doc might have 20+ pages in a tree hierarchy. Quip organizes content as threads inside folders. Each Quip document (thread) is a standalone entity that belongs to one or more folders.

To preserve hierarchy:

1. Map Coda docs → Quip folders. Create a Quip folder for each Coda doc.
2. Map Coda pages → Quip documents. Each Coda page becomes a separate Quip thread inside the corresponding folder.
3. Map Coda subpages → Quip subfolders. If Coda pages have nested children, create Quip subfolders.

Use the Quip API's folder creation endpoint:

POST https://platform.quip.com/1/folders/new

Quip folders are more like tags than traditional filesystem directories — a thread can exist in multiple folders simultaneously. Your Coda page tree will usually need approximation rather than exact replication. Ensure your script uses POST /1/folders/add-thread correctly without creating duplicate documents.

Post-Migration QA and Validation

No migration is complete without verification. Run QA at three levels: object counts, content fidelity, and link integrity.

Row Count Validation

For every Coda table, compare source row count (from Coda API) against destination row count (from Quip Get Thread → parse HTML → count <tr> elements). Flag any table where counts do not match. Common causes: Quip's 100,000-cell limit truncating large tables, rows dropped during rate-limit errors, or malformed HTML in batch inserts.

Document Completeness

Verify every Coda page has a corresponding Quip thread. Compare your {coda_page_id → quip_thread_id} mapping table against the source page list. Check for truncated documents — Quip's API may silently truncate HTML payloads that exceed ~1 MB. Open a sample of documents in the Quip UI and compare against the Coda source.

Attachment Verification

• Confirm all images render in Quip documents (blob URLs resolve correctly).
• Verify file attachments are downloadable from Quip threads.
• Check that image dimensions and quality were preserved (Quip may resize large images).

Link Integrity

Run a link checker across all migrated Quip documents. Any remaining coda.io URLs are broken links that your rewriting pass missed. Verify that internal cross-references between Quip documents resolve correctly.

Folder Structure Audit

Walk the Quip folder tree and compare it against the Coda doc/page hierarchy. Confirm no orphaned documents ended up in private folders due to missing member_ids parameters during creation.

Staged Cutover

A staged cutover usually works best: keep Coda live while you do the bulk load, freeze edits for a short delta window, migrate only changed pages and rows, rerun validation, then switch users once the target passes QA. This keeps downtime low and makes rollback cleaner. Re-run the migration against the same source IDs in a test tenant to confirm idempotency before go-live.

Performance Considerations for Large-Scale Migrations

At scale (500+ documents, 50+ tables, 100,000+ rows), several bottlenecks compound:

• Quip's 50 req/min per-token limit is the primary constraint. Parallelize across multiple tokens if your Quip plan supports it, but stay under the 600 req/min company-wide ceiling.
• Coda's 125 MB API wall means pre-migration doc splitting is not optional for large workspaces. Audit doc sizes before writing any migration code.
• Quip's 100,000-cell spreadsheet limit means a Coda table with 25 columns and 4,000 rows is right at the ceiling. Tables exceeding this must be split across multiple Quip spreadsheets — which breaks any cross-sheet references.
• Quip's recommended 30,000-cell limit for performance means that even within the hard ceiling, large spreadsheets will be slow to load and edit in Quip. Plan for user complaints.
• Payload size: Quip's ~1 MB limit on new-document and edit-document payloads means very long pages must be chunked and assembled in multiple API calls.

When to Bring in Help

A Coda-to-Quip migration is technically achievable with the API approach described above. But the engineering time adds up:

• Building extraction scripts that handle Coda's paginated API, async exports, and 125 MB limit
• Writing the HTML transformation layer that correctly wraps tables and cleans rich text
• Implementing Quip-specific 503/429 backoff logic (not standard retry-after behavior)
• Running multi-pass link rewriting after all documents are created
• Building automated QA that validates row counts, attachment integrity, and folder structure

For a 50-doc workspace with simple pages, this is a weekend project. For 500+ docs with complex tables, cross-doc references, and attachments, it is a multi-week engineering effort with real risk of data loss at the edges.

A safe Coda-to-Quip migration is boring on go-live day. Pages are already split. Tables are already flattened. Rate limits are already respected. Source IDs are already preserved. Internal links are already rewritten. If you build around the actual product state — not old import tutorials — you can make the move cleanly.