What the Quip to Slack Canvas Converter Doesn't Migrate

What the Quip to Slack Canvas Converter Doesn't Migrate

The native Quip-to-Slack Canvas converter does not migrate spreadsheets, Live Apps, @date mentions, or inline annotations with positional anchors. These are not temporary gaps — Slack Canvas was built on the Quip codebase, and these omissions reflect deliberate scope decisions in how that codebase was adapted for Slack's surface. Salesforce states that roughly 65% of Quip documents are compatible with Slack Canvas, a figure that refers specifically to rich-text documents without embedded spreadsheets or Live Apps. If your workspace relies on the other 35% — primarily spreadsheet-heavy and Live-App-heavy documents — the official converter alone will not get you to parity. (help.salesforce.com)

Last verified: June 2025. Slack updates Canvas regularly; confirm cell limits and API behavior against current documentation before executing a migration.

This guide covers each gap in detail, explains the technical reasons behind it, and clarifies why common workarounds — including copy-paste — do not help. It also covers permission mapping, folder structure loss, and API rate limits that most migration guides omit.

For the full picture of what does survive, see our companion piece: Quip to Slack Canvases Migration: The Official Salesforce Path. If Slack Canvas isn't the right destination at all, our Quip End-of-Life Playbook covers every alternative.

How the Native Converter Actually Works

The Quip-to-Slack Canvas converter is an in-product flow that converts one Quip document at a time into a Slack canvas. Slack's own setup guide is explicit: "Bulk document conversion isn't supported at this time." (slack.com)

Each converted Quip document becomes read-only in Quip. Admins can allow an undo window of up to 10 days, during which the Canvas can be deleted and the original Quip document restored. After that window closes, the Canvas version is the active destination. (help.salesforce.com)

The converter handles rich text, headings, lists, inline images, @user mentions, and basic formatting. Quip's release notes describe it as converting "content, mentions, and access" in one click. That description is accurate for standard rich-text documents — and misleading for anything else.

The one-at-a-time constraint is the most severe operational bottleneck. Salesforce does not publish a benchmark for per-document conversion time. Internal estimates from organizations that have run pilot conversions range from 20–60 seconds per document depending on document size and network latency; at a conservative midpoint of 40 seconds, manually converting 10,000 documents would require over 110 hours of continuous clicking. For any organization with more than a few hundred documents, this alone makes the native path unviable without supplementary tooling.

What Does Not Convert: The Complete List

Before diving into each gap, here is the full inventory of what the native converter drops:

Do Quip Spreadsheets Convert to Slack Canvas?

No. Salesforce's conversion FAQ states that Quip Spreadsheets cannot be converted to Slack Canvas. (help.salesforce.com)

Slack Canvas has no spreadsheet engine. Canvas supports simple tables — flat grids of cells that hold text, links, and basic formatting — but nothing resembling Quip's spreadsheet functionality. The constraints are hard platform limits:

• 300 cells per table. Slack's Canvas API caps tables at 300 cells in any combination of rows and columns. Quip spreadsheets support up to 30,000 cells. (docs.slack.dev)
• No formulas. Canvas tables are static text grids. No formula bar, no =SUM(), no cell references, no computed values. A cell containing =SUM(B2:B50) in Quip will at best migrate as the static output value, breaking the model entirely.
• No cell formatting. No number formatting, conditional formatting, cell background colors, or column-width control.
• No multi-tab sheets. Quip spreadsheets can contain multiple tabs. Canvas has no tab concept for tables.

A 500-row Quip spreadsheet won't just lose formatting — it won't fit at all.

This also hits embedded spreadsheet usage inside documents. Quip lets users insert a spreadsheet into a document with @spreadsheet, which means many teams store spreadsheet logic inside otherwise normal docs. The parent document may convert while the embedded spreadsheet behavior is silently dropped. Do not treat document compatibility as spreadsheet compatibility. (resources.docs.salesforce.com)

For spreadsheet-heavy Quip estates, Salesforce's own published path is to export as .xlsx or use the Quip API programmatically — not to convert to Canvas. (help.salesforce.com)

Do Quip Live Apps Migrate to Slack Canvas?

Not as the original Quip Live App runtime. Every Live App instance is either silently dropped or fundamentally altered during conversion. (help.salesforce.com)

Quip Live Apps are interactive, embedded applications inside Quip documents — Kanban boards, calendars, Salesforce record viewers, Jira issue embeds, polls, countdown timers, and process bars. Salesforce introduced them at Dreamforce 2017, and they became the core differentiator for Quip in Salesforce-first organizations.

The technical blocker is straightforward: Slack's Canvas documentation states that "Block Kit is not supported in canvases." Block Kit is Slack's framework for interactive UI components in messages and modals. Without Block Kit support inside canvases, there is no mechanism to render interactive widgets — no Kanban columns, no calendar views, no live record cards. (docs.slack.dev)

Salesforce's conversion FAQ says live apps like Calendar and Kanban will "change in appearance" and some data is preserved. That is Salesforce's way of saying the interactive behavior — dragging cards, moving calendar events, editing records — does not survive. It is data carryover with behavior and permission caveats, not object parity. (help.salesforce.com)

Kanban and Calendar Live Apps

Calendar and Kanban content may still exist after conversion, but not as the original Quip widgets. Salesforce's Quip documentation describes real behavior inside those apps — dragging calendar events, moving Kanban cards, handling size and performance limits. If your process depends on those interaction semantics, plan for rebuild work rather than assuming the converter preserved them. The replacement path in Slack is Workflow Builder for Kanban-style status flows, or a dedicated project management tool for teams that need full board functionality.

Salesforce Record and Salesforce List Live Apps

Quip's Salesforce Record Live App let users view and edit CRM records directly inside documents — deal status, contact details, opportunity data — with bidirectional sync back to Salesforce. Slack can add dynamic Salesforce data to a canvas through its own native integration, and Salesforce says some data may carry over. But the conversion FAQ warns that view or edit access may change depending on org mapping and permissions, especially when the Quip team and receiving Slack team are tied to different Salesforce orgs. Every Salesforce-backed document needs user-level validation after conversion. (slack.com)

Salesforce also notes a topology constraint: a single Quip site can connect to only one Slack workspace or Slack organization at a time. If your teams span multiple Slack workspaces, this adds a planning dependency. (help.salesforce.com)

Jira and Third-Party Live Apps

Jira is a replacement job, not a native conversion. Salesforce states that the Quip-built Jira app is retired along with all third-party live apps in the AppExchange catalog. Slack may let teams work with Jira-related items inside canvases through Slack-native integrations or unfurls, but the converter does not turn a Quip Jira embed into a live Slack Jira object. The same applies to Zendesk, Smartsheet, and any other third-party Live App. (help.salesforce.com)

What About Quip's Export Live App API?

Quip offers an Export Live App API that can export Live App data (Salesforce Record, Salesforce List, Calendar, Kanban Board, Project Tracker) to HTML. But this produces a static snapshot — the interactivity, bidirectional sync, and live-update behavior are gone. And even that static HTML cannot be inserted into a Canvas via the Slack API, which accepts markdown, not arbitrary HTML. The Export Live App API is useful for archival or for populating a non-Slack destination; it does not create a migration path into Canvas.

Do Quip @date Mentions Survive the Conversion?

No, not as Quip date objects with reminder behavior. (help.salesforce.com)

Quip's @date mention is an inline, interactive date chip embedded in document text. Users type @ followed by a date, and Quip renders a live element that can trigger notifications, change color as deadlines approach, and sync with calendar Live Apps. Salesforce's Quip help describes them as clickable date links with timezone formatting and pre-deadline notification capabilities. (help.salesforce.com)

Slack's Canvas documentation does not include a Quip-style date mention type — it documents @ mentions for users and channels only. Salesforce's conversion FAQ states that mentions unsupported in Slack may become plain text. Mihai Parparita, an ex-Quip engineer who worked on the Canvas prototype, confirmed this gap directly, listing "date mentions" among features that had not made the transition. (blog.persistent.info, docs.slack.dev)

The dates survive as text at best. The structured data, interactive behavior, and reminder workflow are lost. If teams used @date mentions for lightweight task management, approvals, or launch reminders, that behavior needs a separate destination — typically a dedicated task management tool or Slack's own reminder functionality rebuilt manually.

Do Inline Comments Keep Their Exact Anchors?

Not with documented fidelity. The comment text may survive as Slack thread messages associated with the canvas, but the positional relationship — which comment was on which paragraph — is broken. (help.salesforce.com)

Inline annotations in Quip are comments anchored to a specific section of a document, identified by Quip's internal section ID system. Quip's API documentation describes this architecture: "Quip documents are broken down into smaller units we call sections. Every paragraph in a document is a separate section, as is every item in a list or cell in a table." The HTML exported via the Quip Automation API includes id attributes corresponding to these section IDs.

Here is a simplified example of how Quip's API exposes this structure:

{
  "id": "thread_12345",
  "html": "<p id='section_abc123'>This is a critical sentence.</p>",
  "annotations": [
    {
      "id": "annot_9876",
      "section_id": "section_abc123",
      "text": "Are we sure about this metric?"
    }
  ]
}

The problem is twofold:

1. Section IDs don't survive export. When Quip content is converted to Canvas, the internal section ID system is not preserved. Canvas uses its own document structure. A known Quip API issue demonstrates this fragility: even within Quip itself, replacing a section's content detaches its annotations — the UI shows "These comments refer to a section of the document that has been deleted."

2. Canvas API has no position-anchored comment endpoint. Slack's Canvas API provides methods to create and modify canvas content, but there is no public API method to attach a comment to a specific position within a canvas. In the Canvas UI, users can manually add comments to sections, but this cannot be automated at migration scale. (api.slack.com)

For documents with dozens of review annotations, this turns a structured review thread into an unanchored pile of messages. For legal teams, compliance officers, or engineering groups who rely on historical comment threads for decision-tracking, losing positional annotations means losing much of the document's value.

Preservation approach: The Quip Automation API allows extraction of annotations with their section IDs before conversion. The Quip API applies rate limits (typically 50 requests per minute per access token for most endpoints; verify current limits in the Quip API documentation before building extraction tooling). Extracting annotations early preserves the section-ID-to-comment mapping as a reference record, even though the target Canvas cannot reconstruct the anchoring. Our Quip export guide covers the extraction process in detail.

What Happens to Permissions and Folder Structure?

These are the two most common enterprise migration failure modes, and most migration guides omit them entirely.

Permission Mapping

The Quip-to-Slack Canvas converter migrates "access" in the sense that existing Quip workspace members retain access to converted canvases. However, Quip's permission model and Slack's permission model are structurally different, and several common Quip permission configurations have no direct Canvas equivalent:

• Link-based sharing (public links). Quip documents can be shared via a public link accessible to anyone with the URL, including people outside the Quip workspace. Canvas does not support public link sharing in the same way. Converted canvases are scoped to Slack workspace members or specific channels. External stakeholders who accessed Quip documents via public links lose access after conversion.
• External shares to non-Quip users. Quip supports guest accounts — external users who access specific documents without a full Quip license. After conversion, guests need a Slack account in the receiving workspace. Guests who don't have one lose access. This requires either provisioning new Slack guest accounts or finding an alternative way to share converted canvases externally.
• Document-level permissions vs. channel-level permissions. In Quip, permissions are set per document. In Slack, a canvas attached to a channel inherits the channel's membership by default. A private Quip document with 3 collaborators may convert into a canvas in a channel with 300 members. Audit channel membership before linking canvases.
• Salesforce org mapping. As noted above, Salesforce Record Live Apps inherit access rules from the connected Salesforce org. When the Quip-connected org and Slack-connected org differ, record-level permissions need re-validation post-conversion.

Folder Hierarchy

Quip organizes documents in nested folder hierarchies — folders within folders, with documents in multiple locations simultaneously via shortcuts. Canvas has no native folder concept. Canvases live in channels or in direct messages; there is no hierarchical namespace.

The converter does not attempt to recreate folder structure. Converted canvases are placed in the location the admin designates during conversion setup. A Quip folder tree with 50 nested folders and 2,000 documents becomes a flat list of canvases that must be manually associated with appropriate Slack channels. For large workspaces, this structural loss is often more disruptive than the feature gaps — teams lose the navigation model they relied on to find documents.

If folder hierarchy is critical to your information architecture, Slack Canvas is not a structurally equivalent destination. Alternatives that preserve hierarchical organization include Notion (nested pages), Confluence (spaces and page trees), and SharePoint (document libraries with folder structures). See our 2027 decision guide for a full comparison.

Why Copy-Paste Is Not a Workaround

Copying from Quip and pasting into Canvas does not recover the missing types. Mihai Parparita, an ex-Quip engineer who co-built the original Canvas prototype at Slack, tested exactly this. He wrote that he "was also hoping that copying/pasting content from Quip into Slack canvas was a backdoor way to get some of features that have not (yet?) made the transition (spreadsheets, date mentions, etc.), but it does not appear to work." (blog.persistent.info)

This isn't a clipboard format issue fixable with a browser extension. When you copy content in Quip, the clipboard stores multiple representations — plain text, text/html, and sometimes proprietary MIME types. When you paste into Canvas, the editor only accepts a sanitized subset of the HTML:

• Spreadsheets are pasted as static text or basic HTML tables, still subject to the 300-cell limit.
• Live Apps are ignored because the clipboard only captures their static HTML fallback — often an empty <div> or a placeholder image.
• Comments are not captured by the clipboard at all.

Copy-paste recovers plain text and basic rich-text formatting — the same content the converter already handles. It adds nothing for the features the converter drops.

Why These Gaps Are Deliberate, Not Backlog Items

Slack Canvas was built on the Quip codebase. This is confirmed by multiple primary sources.

Slack's engineering blog states: "We've been working to bring components of Quip's technology into Slack with the canvas feature." It confirms that "Quip's backend, which powers both Quip and canvas, is written in Python." Parparita's technical analysis showed that Canvas uses Quip's DOM structure, CSS class names, and the same minified JavaScript controller. Slack's CPO stated directly: "Canvas is taking the collaborative components of Quip and integrating them natively into Slack." (slack.engineering)

This shared lineage is precisely what makes the gaps significant. The Quip team built Canvas. They had full access to the spreadsheet engine, the Live App framework, the @date mention system, and the annotation anchoring model. These features were not ported because Canvas was scoped as a different product — a lightweight, persistent information surface attached to Slack channels, not a full document and spreadsheet suite.

That distinction matters for planning. When a feature is missing because the target platform never had access to the source code, there's reason to expect it on a roadmap. When the same engineering team chose not to port a feature from one product to another, the gap reflects a product decision about what Canvas is meant to be. Organizations waiting for spreadsheet support or Live App equivalents in Canvas are waiting for something that would require a fundamental repositioning of the product.

Feature-to-Destination Mapping: Where Should Each Gap Go?

The native converter handles the straightforward 65% of most Quip workspaces — rich-text documents without embedded logic. The remaining 35% requires routing to the right destination. This table maps each missing feature to viable alternatives and their fidelity:

For detailed migration guidance by destination: Quip to Notion | Quip to Coda | Quip to SharePoint

What This Means for Your Migration Plan

Use this decision framework to route content before touching the converter:

Use the native converter if your documents are:

• Rich-text only (meeting notes, project briefs, wikis, onboarding guides)
• Accessed by internal Slack workspace members only
• Not dependent on folder-based navigation
• Free of embedded spreadsheets, Live Apps, or dense annotation threads

Do not use the native converter as the sole path if:

• Spreadsheets with formulas or more than 300 cells → Export as .xlsx to Google Sheets or Excel. For structured-data destinations, Notion databases or Coda tables are viable targets.
• Live Apps (Kanban, Calendar, Salesforce Record) → The interactive behavior must be rebuilt in Slack Workflow Builder, native Salesforce–Slack integrations, or a third-party tool. Data can be extracted via Quip's Export Live App API as a static snapshot before Quip shuts down.
• Heavily annotated documents → Extract comments with section-ID mapping via the Quip Automation API before conversion. You'll lose positional anchoring in Canvas, but you'll preserve the comment content and its original location reference as a structured record.
• @date mentions → Audit documents for @date usage and convert to plain-text dates or structured metadata before migration. For teams that need live date tracking, route these documents to Notion or Coda.
• External collaborators or public link sharing → Audit external access before conversion. Provision Slack guest accounts for external stakeholders who need ongoing access, or move those documents to a platform that supports public sharing natively.
• Deep folder hierarchies → Map your Quip folder structure to Slack channels before converting. Documents in deeply nested folders need a channel home; without pre-planning, they become unfindable.

If you're building custom extraction tooling, note that Slack's Canvas API is markdown-first and each document_content object is limited to 1 MiB. Complex Quip objects typically need decomposition and remapping, not a single conversion pass. The Quip Automation API rate limits (verify current limits at quip.com/dev/automation/documentation) apply to both document and annotation extraction — design your extraction pipeline to handle throttling, especially for large annotation-heavy document sets. (docs.slack.dev)

For alternative destinations, see our guides on Quip to SharePoint and the 2027 decision guide.