Coda to Confluence migration requires custom API scripts or a managed service — there's no native tool. Key blockers: Coda's 125 MB API doc limit and strict rate limits on both sides.
There is no native migration path from Coda to Confluence — no one-click importer, no Coda option in Confluence's import menu, no Atlassian-built migration wizard. Coda builds a Confluence importer for the reverse direction, but moving to Confluence from Coda requires manual work, custom scripts, or a migration partner. Coda is a document-database hybrid where a single doc contains pages of rich text and relational tables with formulas, lookups, cross-table references, buttons, and automations. Confluence is a wiki built on XHTML-based storage format pages organized in a hierarchical space → page → child-page tree with static tables and macros — but no concept of relational lookups, formula columns, or cross-table references. This fundamental gap means every migration must flatten formulas to static values, break cross-doc references, convert tables to HTML or child pages, remap all internal Coda URLs to Confluence page links, and handle the hard 125 MB Coda API doc limit that blocks all API access to oversized docs.
Read this first
Pair-specific gotchas that catch teams out. Each one has cost somebody a weekend.
If the business value lives in Coda's relations, formulas, and interactive controls,
If the business value lives in Coda's relations, formulas, and interactive controls, Confluence is only a partial destination. You can preserve information, but not behavior — at least not without redesign.
What you lose
Formula columns, cross-table lookups, conditional formatting, buttons, automations, comments, version history, and @-mentions. The manual method preserves content text and static table data — nothing else.
The 125 MB wall
If any single Coda doc exceeds 125 MB (excluding attachments), the Coda API will block all access to it. There is no "partial read" mode. You must manually split the doc in Coda's UI before an API-based migration can proceed. This affects a small percentage of docs, but if you are migrating a large knowledge base, audit doc sizes first.
Pre-migration audit
Before writing any code, run a Coda API inventory. List all docs (GET /docs), count pages and tables per doc, check doc sizes, and identify any docs over 100 MB. This 30-minute exercise will save you days of debugging.
The runbook
Work top to bottom. Tick steps as you go — your progress is saved in this browser.
01 Discovery Decide what content deserves to move before you plan how to move it.
Objective A content inventory with a keep/rewrite/retire decision on every article and an agreed URL strategy.
Keep these open
-
Inventory all content in Coda
Count articles, categories, attachments, images and embedded media, and pull page views and last-updated dates for each article. Usage data is what makes the next decision defensible rather than political.
Data Profiler Get real record counts instead of estimating from memory -
Make a keep, rewrite or retire call on every article
Most knowledge bases are half stale. Migrating everything imports the staleness and doubles the work; use views and last-updated to triage, and get the owning team to confirm. This usually removes 30-50% of scope.
Migrating stale content is the most common knowledge-base migration mistake — it costs effort and actively degrades the new site.
-
Agree the URL and redirect strategy
Decide the Confluence URL structure and whether you can serve 301 redirects from the old paths. Public help centres carry real search traffic and inbound links; losing it is a measurable commercial impact.
Without 301 redirects from old article URLs you lose accumulated search ranking and every external link and bookmark breaks.
-
Map the information architecture
Document the current category tree and design the target one, checking whether Confluence supports your nesting depth. Deeply nested hierarchies frequently have to be flattened, which changes navigation for everyone.
-
Confirm permissions, audiences and localisation scope
Establish which content is public, internal or restricted, and how Confluence models that. Then confirm how many locales you have and whether translation relationships between articles survive the move.
Coda → Confluence specifics
- Coda tables with formula columns
- lose all computed values. Confluence tables are static HTML; there is no formula engine.
- Cross-doc references and lookups
- break entirely. There is no equivalent concept in Confluence.
- Linked tables
- displayed across multiple Coda pages export as disconnected, static tables.
- Coda automations and buttons
- have no Confluence counterpart unless you rebuild them as Jira workflows or third-party macros.
- Coda views
- (filtered, sorted, or grouped views of a table) are not separate objects in the Coda API — they are accessed as tables with their own IDs. A view returns only the rows and columns visible in that view, not the full underlying table. During migration, you must decide: export the canonical table (complete data) or export each view separately (preserving the team's working perspective). Most migrations should export the canonical table and recreate filtered views as Confluence saved searches or child-page structures.
Don't move on until
- Full content inventory with page views and last-updated dates
- Keep / rewrite / retire decision recorded per article
- URL and redirect strategy agreed with whoever owns SEO
02 Data Audit Audit the markup, the links and the assets — that is where KB migrations break.
Objective A content export with markup, internal links and every embedded asset accounted for.
Keep these open
-
Export content and assess markup fidelity
Export articles in the richest format available and inspect what survived: tables, code blocks, callouts, nested lists, anchors and embedded video. Rich formatting is where fidelity is lost, and it is lost quietly.
HTML-to-Markdown conversion routinely mangles nested lists, tables and code blocks. Inspect the output rather than trusting the converter.
Data Profiler Profile the Coda export for nulls, outliers and type drift -
Inventory every internal link and cross-reference
Extract all internal links, anchor links and article cross-references. These break by default: the target URL structure differs, so every internal link needs rewriting as part of the load, not afterwards.
Internal links left pointing at old URLs turn the new knowledge base into a maze of 404s on day one.
-
Inventory images, attachments and embedded media
List every asset with its URL, size and type, and confirm each still resolves. Assets hosted on the old platform's CDN will 404 the moment you decommission it, so they must be rehosted, not referenced.
Images referenced from the source platform's CDN break when the old account closes. Download and rehost every asset.
-
Find and fix broken links and orphans
Crawl for existing broken internal and external links, and find articles no category links to. Fix them before migrating — a migration is a bad time to discover pre-existing rot.
-
Check for PII and internal information in public content
Scan for customer names, internal hostnames, credentials in code samples and screenshots containing real data. Republishing these on a public help centre is a disclosure, and screenshots are the usual culprit.
PII & Compliance Scanner Find regulated fields before they land in a new system -
Normalise metadata
Standardise authors, tags, timestamps to UTC, and locale codes. Author mapping needs a decision for people who have left — attribution to a deleted user usually fails the import.
Don't move on until
- Content exported with markup fidelity assessed
- Every internal link and asset reference inventoried
- Broken links and missing assets fixed or logged
03 Field Mapping Map structure, metadata, permissions and — above all — URLs.
Objective A mapping covering article fields, taxonomy, permissions and a complete old-to-new URL map.
Keep these open
-
Map the article schema
Map title, body, excerpt, author, dates, status, tags, SEO metadata and any custom properties. Confirm which fields Confluence lets you set on import versus which it computes — computed dates are a common surprise.
Schema Mapper Opens pre-loaded with the Coda → Confluence field pair -
Map the taxonomy and hierarchy
Map categories, sections and tags to the target structure, resolving any nesting-depth limit explicitly. If you must flatten, decide how the lost level is preserved — usually as a tag or a title prefix.
JSON to CSV Converter Flatten nested API responses into a reviewable sheet -
Map permissions and audience segmentation
Map public, logged-in, and role-restricted visibility to Confluence's model. Verify the mapping deliberately: internal content accidentally published publicly is the highest-severity failure in this whole category.
Permission mapping errors publish internal documentation to the open web. Verify visibility on every restricted article after load.
-
Build the complete old-to-new URL map
Produce a row per article mapping the old URL to the new one, then confirm exactly where the 301s will be served — Confluence, a CDN, or your own web layer. Without this artifact the redirect step cannot be executed at all.
-
Define the markup conversion and link-rewrite rules
Specify how each markup construct converts and how internal links are rewritten using the URL map. Write it as a repeatable transform, not manual edits — you will run it more than once.
Data Format Converter Reshape the export into the format Confluence's importer expects -
Plan localisation and freeze the spec
Confirm how translated articles link to their source language in Confluence, then version and sign off the mapping spec.
Don't move on until
- Article schema and taxonomy mapped
- Permission and audience model mapped to target equivalents
- Complete URL map produced and redirect method confirmed
04 Test Migration Pilot the hardest articles, then read them.
Objective A pilot load whose formatting, links, assets and search all hold up under human review.
Keep these open
-
Configure Confluence with the agreed structure
Create the category tree, permission groups, locales and branding before loading. Articles loaded before their categories exist land uncategorised and have to be moved by hand.
-
Pick the most difficult articles as the pilot
Choose 20-50 articles for difficulty: the longest, the most heavily formatted, ones with tables and code blocks, deep internal linking, many images, embedded video, restricted visibility, and non-Latin scripts. Easy articles prove nothing.
-
Run the conversion and load with link rewriting
Apply the markup conversion, rewrite internal links from the URL map, upload and re-reference assets, then load. Log every conversion warning rather than suppressing it.
-
Read every pilot article side by side
Open source and target together and compare rendering. This step is manual on purpose: no automated check catches a table that collapsed into a paragraph or a code block that lost its indentation.
-
Click every link and load every asset
Verify each internal link resolves, each image loads from the new host, each attachment downloads and each embed plays. Assets still served from the old CDN are the defect that surfaces only after decommissioning.
Migration Validation Tool Diff the pilot batch against source before scaling up -
Test search and permissions
Search for known terms and confirm the right articles rank, then verify every restricted pilot article is invisible to an anonymous browser. Test permissions from a logged-out session, not an admin one.
Don't move on until
- Complex articles render correctly with formatting intact
- Every internal link and asset in the pilot resolves
- Search returns sensible results for the pilot content
05 Cutover Publish, redirect, and keep the search traffic.
Objective All in-scope content live in Confluence with redirects serving and search engines informed.
Keep these open
-
Load the full content set ahead of the switch
Run the full conversion and load into Confluence, unpublished or on a staging domain. Content migration differs from data migration here: you can stage the whole thing before anyone sees it.
-
Publish the runbook with the redirect step first-class
Sequence the freeze, final delta, publish, redirect activation, sitemap submission and link updates, with owners for each. Redirect activation is the step with lasting commercial consequences, so it gets explicit ownership.
-
Freeze editing and migrate the delta
Stop editing in Coda, then convert and load anything changed since the full load. Announce the freeze to every team that publishes — content teams are used to editing whenever they like.
-
Publish and verify permissions live
Publish the content set, then immediately verify restricted articles are not publicly reachable using an anonymous session. Do this before announcing the new site, not after.
Verify restricted content from a logged-out browser. An admin session will show you everything and tell you nothing.
Migration Validation Tool Confirm the final delta landed before you reopen -
Activate 301 redirects and submit the sitemap
Turn on the redirects from the URL map, then spot-check a sample of high-traffic old URLs and confirm each returns 301 to the right article. Submit the new sitemap and keep the old one reachable until search engines have recrawled.
Redirect chains and redirect loops both leak ranking. Verify each redirect resolves in a single hop.
-
Repoint in-product and support links
Update help links embedded in your product, in support macros, in email templates and in onboarding material. These are the links your existing customers actually use, and they are easy to forget.
Don't move on until
- All content loaded, categorised and correctly permissioned
- 301 redirects live and verified from a sample of old URLs
- Sitemap submitted and support links repointed
06 Validation Watch traffic, links and search rankings for weeks, not hours.
Objective Verified content completeness, healthy redirects, and search traffic recovered to baseline.
Keep these open
-
Reconcile content counts and assets
Compare article counts by category and status, plus asset counts, against source. Confirm every article in the keep list is present and every retired one genuinely is not.
Migration Validation Tool Reconcile Coda and Confluence record-for-record -
Crawl the new site for broken links and assets
Run a full crawl for 404s, broken images and missing attachments, and fix everything it finds. Repeat the crawl after the fixes rather than assuming they worked.
-
Verify the redirects at scale
Test every mapped old URL for a single-hop 301 to the right destination. Chains and loops both leak ranking and are invisible unless you check the whole map, not a sample.
-
Monitor organic traffic and rankings for four to eight weeks
Track organic sessions, impressions and rankings for your top articles against baseline. A dip in the first two weeks is normal; one that has not recovered by week six is a redirect or indexing problem to investigate.
Do not decommission the old platform until search traffic has recovered — you may still need the old URLs to diagnose a ranking loss.
-
Verify search, permissions and feedback loops
Confirm on-site search returns good results for real queries, re-verify restricted content from a logged-out session, and check article feedback and analytics are collecting.
-
Sign off and decommission on a delay
Get acceptance against the Discovery criteria, keep Coda available read-only until traffic has recovered, take a final export, and only then close the account.
Don't move on until
- Article counts reconciled and no broken links remain
- Redirects returning 301 with no chains or loops
- Organic traffic recovered to within tolerance of baseline
Field mapping reference
The field-by-field mapping for each object. Use this as the starting point for your mapping spec.
Object Equivalent
| Coda field | Confluence field | Notes |
|---|---|---|
| Page (canvas content) | Confluence page body (XHTML) | HTML sanitization, macro conversion |
| Table (with columns/rows) | Static <table> or Confluence table macro | Flatten formulas to last-known values |
| Formula column | Static text column | Evaluate and freeze values |
| Lookup / Relation column | Plain text or cross-link | Resolve references, insert page links |
| Image attachment | Page attachment + <ac:image> tag | Upload via attachment API, update references |
| @-mention | Confluence user mention macro | Map Coda user IDs → Atlassian account IDs |
| Button / Automation | Nothing (no equivalent) | Document in migration notes |
| View (filtered/sorted table) | Filtered child-page set or skip | Export canonical table; recreate view logic manually or via labels |
| Pack sync column | Static text column | Freeze last-synced value; plan separate integration if live data needed |
Risk matrix
Per-object risk for this pair. Plan extra validation around anything marked high.
| Object | Risk | Notes |
|---|---|---|
| Formula Columns | high | Confluence has no formula engine — all computed values must be frozen as static text at migration time |
| Cross-Doc References & Lookups | high | No Confluence equivalent exists — linked tables across docs break entirely |
| Buttons & Automations | high | No Confluence counterpart unless rebuilt as Jira workflows or third-party macros |
| Internal Coda Links | high | All coda.io URLs break without a full source-to-target ID registry and link rewriting pass |
| Oversized Docs (>125 MB) | high | Coda API refuses all requests — doc must be manually split before extraction |
| Table Data (Large Tables) | medium | Tables over ~200 rows need child-page conversion; page bodies over ~64 KB can trigger Confluence 400 errors |
| @-Mentions & User Mapping | medium | Coda user IDs must be mapped to Atlassian account IDs — mismatches break mentions silently |
| Attachments & Images | medium | Coda CDN URLs are temporary and expire — files must be downloaded immediately and re-uploaded to Confluence |
| Page Hierarchy | low | Coda's flat-page-within-a-doc model maps reasonably well to Confluence's space → page → child-page tree |
| Rich Text Content | low | Page body text migrates cleanly when using HTML as an intermediate format and sanitizing XHTML special characters |
The hard parts
What makes this specific migration difficult, beyond the mechanics.
125 MB API Wall
Coda docs at or above 125 MB are completely blocked from API access — no partial reads, no workaround. You must manually split the doc in Coda's UI before migration can proceed.
Formula & Automation Loss
Confluence has no formula engine, no buttons, and no automations. All computed columns must be frozen to static values at migration time, and automations must be documented for manual rebuild.
Internal Link Remapping
Every Coda page uses a unique thread-style URL. After migration, all internal links must be rewritten to point at Confluence page IDs or they break permanently.
Table Conversion Decisions
Each Coda table must become either a static HTML table in a Confluence page (limited to ~100–200 rows) or a set of child pages with properties — a decision that changes the entire migration approach per table.
Strict Rate Limits Both Sides
Coda allows only 100 reads per 6 seconds and 10 writes per 6 seconds. Confluence enforces burst limits and points-based quotas. Both require exponential backoff and adaptive throttling.
What breaks
Known failure modes. Have a recovery plan for each before you cut over.
Coda buttons and automations
— these do not exist in Confluence. Document them in a migration runbook so teams know what manual processes replace the automations.
Cross-doc references
— if Doc A references a table in Doc B, you need to decide whether to merge them into one Confluence space or use cross-space links. Cross-doc formulas that pull live data from another doc will resolve to their last-synced value at export time — verify these values during QA, as stale cross-doc references are a common source of silent data loss.
Conditional formatting
— Coda tables with color-coded rows based on conditions lose all visual context. Consider using Confluence status macros (<ac:structured-macro ac:name="status">) as a partial replacement.
Page-level permissions
— Coda's sharing model (doc-level) does not map to Confluence's page-level restrictions. Plan your permission model in Confluence before migration.
Unicode and special characters
— Confluence's storage format is XHTML-strict. Unescaped &, <, or > in Coda content will cause 400 errors on the Confluence API. Your transformation layer must sanitize all content.
Duplicate page titles
— Confluence requires unique page titles within a space. If your Coda doc has multiple pages with the same name (common in templates), the migration script must append unique suffixes.
Volatile formulas
— Today(), Now(), and User() may return lagging or blank values through the API. Decide before migration whether to freeze these or drop them.
Pack sync and Cross-doc data
— any data pulled into Coda via Packs or Cross-Doc becomes a static snapshot in Confluence. Pack sync columns are readable through the API (you get the last-synced value), but sync metadata, connection credentials, and refresh schedules are not exposed. If the upstream source matters, plan a separate integration in Confluence (e.g., Jira links, direct API connectors, or Marketplace apps) rather than expecting Pack data to stay current.
Coda views
— views appear as separate table IDs in the API. If you export both the canonical table and its views without deduplication, you will create duplicate data in Confluence. Track which table IDs are views (check tableType) and decide per view whether it warrants a separate Confluence page or should be skipped.
Tools used in this playbook
All free, all run entirely in your browser — nothing is uploaded.
FAQ
Is there a native Coda to Confluence importer?
No. Atlassian does not offer a direct importer for Coda. You must use manual exports (Word/CSV), iframe embeds via Coda+ for Confluence, custom API scripts, or a managed migration service.
What are the Coda API rate limits for migration?
Coda's API allows 100 read requests per 6 seconds, 10 write requests per 6 seconds, and 5 doc-content writes per 10 seconds. Docs over 125 MB (excluding attachments) are completely blocked from API access. All limits are per-user across all docs.
Does the Coda+ for Confluence app migrate data?
No. Coda+ for Confluence only embeds Coda documents in Confluence pages via iframes. The data remains in Coda, is not indexed by Confluence search, and will break if your Coda subscription expires. It is a coexistence tool, not a migration tool.
How do I handle Coda formula columns in Confluence?
Confluence has no formula engine. The standard approach is to freeze formula values — read the current computed value from the Coda API at migration time and store it as static text. Alternatively, replace dynamic fields with linked Jira issue fields where those values need to stay current.
What Confluence API limits affect large migrations?
Confluence Cloud enforces burst rate limits per-second and (starting March 2026 for OAuth/Forge/Connect apps) points-based hourly quotas. API token traffic uses burst limits only. Page body content over roughly 64 KB can trigger 400 errors, and queries with body expansion are capped at 50 results per request.