--- title: "Box to Slack Canvas Migration: Should You Move or Index?" slug: box-to-slack-canvas-migration-should-you-move-or-index date: 2026-09-28 author: Rishabh Makhar categories: [Box, Slack Canvas, Migration Guide] excerpt: "Most Box content should not become Slack Canvases. Learn when to convert, when to index, and how to build the channel canvas pattern that actually works." tldr: "Box is a file store, Slack Canvas is a markdown surface. Most teams should keep Box and use Canvas as an index over files — not attempt a full content migration." canonical: https://clonepartner.com/blog/box-to-slack-canvas-migration-should-you-move-or-index --- # Box to Slack Canvas Migration: Should You Move or Index? # Box to Slack Canvas Migration: Should You Move or Index? Most Box content should not be migrated into Slack Canvas. Box is a file store — its primary objects are files, folders, file versions, metadata templates, and collaborations. A PDF, DOCX, or Excel workbook sitting in Box has no meaningful representation as Canvas markdown. The migration that actually works for most teams is not a content conversion but a **navigation layer**: a channel canvas that acts as an index over files that stay files, uploaded to Slack or linked from their current location. This guide covers how to decide what (if anything) gets converted into a canvas, how to build the index pattern that usually wins, the API mechanics and rate limits on both sides, and the metadata and permission problems you will hit along the way. If you are evaluating Slack Canvas as a document home more broadly, our [Quip to Slack Canvases guide](https://clonepartner.com/blog/blog/quip-to-slack-canvases-migration-the-official-salesforce-path) covers the Salesforce-native path, and our [Enterprise Grid migration guide](https://clonepartner.com/blog/blog/slack-enterprise-grid-migration-the-complete-2026-technical-guide) covers workspace consolidation. > [!WARNING] > **Before you start scripting:** Audit your Box estate first. Apply the classification criteria in the next section to a representative sample of 200–500 files. In practice, files that are text-native, actively edited, and not requiring granular permission control make up a small minority of a typical Box estate — often under 10–15% by item count. The rest should remain files. Migrating binary files into markdown canvases is not a migration — it is data loss. ## Should you migrate Box to Slack Canvas at all? For most teams, no — not as a full migration. Box and Slack Canvas solve different problems. **Box** is an enterprise content management platform built around file storage, versioning, granular folder permissions, metadata classification, and compliance workflows like Box Relay and Box Shield. **Slack Canvas** is a lightweight collaborative document surface inside Slack that supports markdown with headings (h1 through h3), lists, tables capped at 300 cells, checklists, and code blocks. ([docs.slack.dev](https://docs.slack.dev/surfaces/canvases/)) The mismatch is structural. Box holds binary files — contracts as PDFs, financials as XLSX, design assets as PSD. Canvas holds markdown text. There is no conversion path that turns a signed contract PDF into something a canvas can render. Box's own Slack integration already covers much of the "make Box accessible in Slack" use case: preview cards for Box links, permission prompts when a shared file is not accessible to everyone in the channel, slash commands like `/box search` and `/box recents`, and even Box as Slack's custom file store with channel-to-folder mappings. Box explicitly positions itself as the content layer for Slack — a strong signal that the supported coexistence pattern is **Box for files, Slack for conversation and indexing**, not mass conversion of Box binaries into native Slack documents. ([support.box.com](https://support.box.com/hc/en-us/related/click?data=BAh7CjobZGVzdGluYXRpb25fYXJ0aWNsZV9pZGwrCPFtTtRTADoYcmVmZXJyZXJfYXJ0aWNsZV9pZGwrCJNvAXt8FToLbG9jYWxlSSIKZW4tdXMGOgZFVDoIdXJsSSJXL2hjL2VuLXVzL2FydGljbGVzLzM2MDA0NDE5NTMxMy1JbnN0YWxsaW5nLWFuZC1Vc2luZy10aGUtQm94LWZvci1TbGFjay1JbnRlZ3JhdGlvbgY7CFQ6CXJhbmtpBw%3D%3D--4ff13fdfbe124521a054fb264a4a2385e4364f3d)) That model has trade-offs. Users without Box accounts cannot upload content into Slack when Box is the custom file store. If you have external Slack users or Slack-first teams with no Box identity, that limitation matters. ([support.box.com](https://support.box.com/hc/en-us/articles/4415585987859-Box-as-the-Content-Layer-for-Slack)) The question is not "how do we move everything" but "which tiny slice is worth converting, and how do we make the rest discoverable from inside Slack?" > [!NOTE] > **Terminology note:** On April 9, 2025, Slack began converting legacy channel and DM canvases into canvases in tabs. In this guide, **channel canvas** means the canvas attached to a Slack channel tab, because that is still how most admins and project teams describe it. The term **index canvas** is used throughout this guide as a descriptive label — it is not an official Slack term. ([slack.com](https://slack.com/help/articles/21290478840979-Feature-change-notice--Channel-canvases)) ## What content is worth converting into a Canvas? ### Classification criteria Content that qualifies for canvas conversion must pass three tests: 1. **It is text-native.** The source document is primarily running text, not a binary format rendered by an external viewer. Apply this test concretely: open the file in a plain text editor. If you see human-readable prose or structured data (not binary garbage), it is text-native. Wiki-style pages, runbooks, onboarding guides, SOPs, and meeting note templates are candidates. PDFs, spreadsheets, slide decks, and images are not. 2. **It is actively edited.** A document with no edits in the last 90 days does not need to live in Canvas. It needs an archive link. Use Box's `modified_at` field to filter programmatically. 3. **It belongs to a specific channel's audience.** Canvas access inherits from channel membership. If a document needs fine-grained permission control — legal-only, finance-only, down to individual file level — it is better served staying in Box where folder-level collaborations handle that natively. All three criteria must be satisfied. A document that is text-native and actively edited, but requires per-user ACLs that cannot be modeled as channel membership, stays in Box. > [!TIP] > **Fast triage test:** Strip the file extension from a Box item mentally. If the content would work as plain structured text with no loss of function, it may belong in Canvas. If meaning depends on formatting, layout, formulas, or an external renderer, keep it as a file. In practice, applying these three filters eliminates the vast majority of a typical Box estate. What survives is usually a small set of living documents: team runbooks, project briefs, and process docs. ### Box Notes: the closest conversion candidate Box Notes deserve a separate discussion because they are the only item type in a typical Box estate that is genuinely document-shaped. A Box Note is stored internally as a JSON object with a proprietary schema. Its top-level structure contains a `doc` key holding a tree of `content` nodes. Each node has a `type` field (`paragraph`, `heading`, `bulletList`, `orderedList`, `codeBlock`, `table`) and, where applicable, `attrs` and `content` arrays. Text runs are represented as leaf nodes with a `text` field and optional `marks` array (bold, italic, link, etc.). A minimal Box Note JSON excerpt looks like this: ```json { "doc": { "type": "doc", "content": [ { "type": "heading", "attrs": { "level": 1 }, "content": [{ "type": "text", "text": "Runbook: API Gateway" }] }, { "type": "paragraph", "content": [ { "type": "text", "text": "Owner: " }, { "type": "text", "text": "jsmith", "marks": [{ "type": "bold" }] } ] }, { "type": "bulletList", "content": [ { "type": "listItem", "content": [ { "type": "paragraph", "content": [{ "type": "text", "text": "Step 1: Check health endpoint" }] } ] } ] } ] } } ``` The conversion mapping is mostly mechanical: `heading` with `level: 1–3` maps to `#`, `##`, `###`; `paragraph` maps to a text block; `bulletList` maps to `-` items; `orderedList` maps to `1.` items; `codeBlock` maps to triple-backtick fences. Unsupported types — `table` cells beyond 300 total, embedded images, inline files — require fallback handling (plain text representation or a "see original" link). What is lost in conversion: Box Notes can embed other Box files inline as previews. These become plain links in Canvas. Mentions of Box users become plain text. Any comment thread attached to the Note is not recoverable in Canvas. There is no turnkey export-to-Canvas path for Box Notes. Conversion requires walking the JSON tree and emitting markdown — custom code, not a built-in tool. ### Content categories | Category | Action | Rationale | |---|---|---| | Box Notes (text-native, actively edited) | Convert to standalone canvas | Document-shaped JSON; mechanical conversion is feasible | | Runbooks, SOPs, onboarding guides (in Box Notes or DOCX) | Convert if text-native filter passes | Living documents with a single channel audience | | Final PDFs, slide decks, finalized DOCX | Upload to Slack or keep in Box; link from canvas index | Not living wikis; binary formats have no Canvas equivalent | | Large media, raw datasets, compliance archives | Leave in Box | Exceed Slack storage limits; compliance controls require Box | | Files requiring file-level ACLs | Leave in Box | Cannot model granular permissions as channel membership | Content that does not pass the conversion filter falls into two categories: **static files** (link from the canvas index, upload to Slack only if Box is being decommissioned) and **heavy data and archives** (leave in Box unconditionally). > [!NOTE] > **Slack file storage limits by plan:** Pro plan — 5 GB total per workspace. Business+ — unlimited. Enterprise Grid — unlimited. If you are on a Pro plan and considering moving Box files into Slack-native storage, the 5 GB ceiling is a hard constraint that makes Box coexistence effectively mandatory for any estate beyond small teams. If you skip triage and attempt to force all Box data into Slack, you will hit storage limits on Pro plans and create an unnavigable structure for users regardless of plan. ## The pattern that usually wins: Canvas as an index over files A **channel canvas index** is a canvas attached to a Slack channel that organizes links to files — files that remain in Box, are uploaded directly to Slack, or both. The Box folder tree is expressed as headings within the canvas, and each file appears as a linked entry under the appropriate heading. This pattern works because it matches what teams actually need: a single place inside Slack to find the right file without leaving the conversation context. It does not try to replicate Box's file management capabilities. It provides a navigation layer. ### Why Canvas cannot replicate a folder tree Slack Canvas has no folder concept. There are no nested containers, no folder-level permissions, no parent-child hierarchy. The only structural tool available is **headings**, and Canvas supports exactly three levels: h1, h2, and h3. A Box folder tree four levels deep cannot be represented faithfully. **Three-level flattening strategy:** - **h1** — Department or top-level domain (Engineering, Finance, Legal) - **h2** — Project, team, or functional area (Backend Services, Q3 Reports, Contracts) - **h3** — Sub-section or document cluster (API Gateway, Auth Service, Vendor Agreements) Anything below h3 gets collapsed into the nearest h3 section as a flat list. For teams with 5+ levels of folder nesting, this is a lossy translation — which is why the index pattern is a navigation aid, not a replacement for Box's folder structure. When a single h3 section would contain more than 20–30 items, split it into a separate channel canvas rather than trying to enumerate everything in one document. ### What the index canvas looks like ```markdown # Engineering ## Backend Services ### API Gateway - [API Gateway Architecture (PDF)](https://app.box.com/s/abc123) — Owner: jsmith, Updated: 2025-11-01 - [Rate Limiting Policy](https://your-slack-workspace.slack.com/files/F06ABC/rate-limiting.pdf) — uploaded to Slack ### Auth Service - [OAuth2 Integration Guide](https://app.box.com/s/def456) - [Auth Runbook](https://your-slack-workspace.slack.com/canvas/auth-runbook) — converted to Canvas ## Frontend - [Component Library Docs](https://app.box.com/s/ghi789) - [Design System Tokens (Figma)](https://www.figma.com/file/...) # Finance ## Q3 2025 Reports - [P&L Statement (XLSX)](https://app.box.com/s/jkl012) - [Board Deck (PPTX)](https://app.box.com/s/mno345) ``` Each link points to the file's actual location. Box files keep their Box URLs. Files uploaded to Slack get Slack file permalinks. The handful of documents converted to canvases get canvas links. Metadata that mattered in Box — document owner, last modified date, version — gets written into the link description as plain text, because once a file leaves Box, its metadata instances vanish. > [!WARNING] > **Bad pattern:** one Slack tab or one canvas per Box folder. You hit the 15-tab limit quickly, and users lose the map. Use the tab bar for a few top-level destinations and the canvas body for the actual hierarchy. ([slack.com](https://slack.com/help/articles/32562841868307-Add-and-manage-tabs-in-channels-and-direct-messages)) ## How Box API enumeration works (and why it is slow) Box has no bulk export endpoint. You cannot request "give me every file and folder in this enterprise" in a single call. Instead, you walk the folder tree one folder at a time using `GET /2.0/folders/{folder_id}/items`. ([developer.box.com](https://developer.box.com/reference/get-folders-id-items/)) You start at the root folder (always ID `0` in Box) and paginate through results, identifying which items are files and which are folders. For every folder you find, you call the endpoint again. Each call returns up to 1,000 items per page. For large datasets, use marker-based pagination (`usemarker=true`) — Box's own documentation notes that offset-based pagination is unreliable at high offset values. ```bash # List items in a folder with marker-based pagination curl -X GET "https://api.box.com/2.0/folders/0/items?limit=1000&usemarker=true" \ -H "Authorization: Bearer " ``` There is also a ZIP download API (`POST /2.0/zip_downloads`), but it is not a full-estate export shortcut. It creates an archive only for items you explicitly name, caps at 10,000 files, and Box recommends keeping total ZIP size under 25 GB. ([developer.box.com](https://developer.box.com/reference/post-zip-downloads/)) Useful for packaging a selected slice — it does not solve discovery. ### The rate limit math Box's general API rate limit is **1,000 requests per minute per user**. Uploads are further limited to 240 per minute per user. Search is capped at 6 per second per user and 60 per minute per user. For a Box estate with 50,000 files distributed across 5,000 folders, you need at minimum 5,000 folder-listing calls (one per folder) plus additional calls for metadata, collaborations, and shared links. At the 1,000-calls-per-minute ceiling, just enumerating the folder structure takes around 5 minutes under perfect conditions — no retries, no 429s, no metadata lookups. In practice, add metadata retrieval (`GET /files/{file_id}/metadata`) and collaboration listing (`GET /folders/{folder_id}/collaborations`) for each item, and you are looking at 3–5 API calls per file. A 50,000-file estate becomes 150,000–250,000 API calls. At 1,000 per minute, that is **2.5–4 hours of enumeration alone** — before you have written a single canvas or uploaded a single file. When you hit the ceiling, Box returns `429 Too Many Requests` with a `Retry-After` header. Your migration script must implement exponential backoff and respect that header. > [!TIP] > **Spread calls across users.** Box rate limits are per-user, not per-application. If you are using a service account with `As-User` headers, the rate limit applies to the impersonated user, not the admin. You can parallelize enumeration by distributing work across multiple user contexts, effectively multiplying your throughput by the number of distinct user identities you operate under. > [!NOTE] > **Service accounts vs. user accounts:** Do not run the extraction script using a standard user's OAuth token. Standard users only see files they have been explicitly granted access to. Use a Box Custom App configured with Server-to-Server authentication (JWT or Client Credentials) and grant it the "Manage Enterprise Properties" scope to ensure you can read the entire corporate directory. ## Slack Canvas API constraints On the Slack side, you are working with a [different set of API limits](https://clonepartner.com/blog/blog/how-to-import-data-into-slack-canvas-api-limits-guide): - **`conversations.canvases.create`** is Tier 2: roughly 20+ requests per minute per workspace. This is the endpoint for attaching a canvas to a channel. `canvases.create` creates standalone canvases. - **`canvases.edit`** is Tier 3: roughly 50+ requests per minute. But only **one operation per API call** — you cannot batch multiple edits. The endpoint can also return `canvas_editing_locked`, so serialize writers per canvas. ([docs.slack.dev](https://docs.slack.dev/reference/methods/conversations.canvases.create/)) - **Canvas markdown content** is limited to **1 MiB (1,048,576 characters)** per `document_content` object. - **Tables** are capped at **300 cells**. An index canvas listing hundreds of files as a table will hit this fast. - **Headings** support h1 through h3 only. No h4, h5, or h6. - **Canvases** are only available on paid Slack plans (Pro, Business+, Enterprise Grid). Free workspaces cannot create or edit standalone canvases. The 20-per-minute create rate means that if you need to generate 200 index canvases (one per channel), canvas creation alone takes 10 minutes at ceiling rate. Not a bottleneck for most teams, but worth knowing for a large Grid org. The single-operation-per-edit constraint matters more. Building a large index canvas through multiple `canvases.edit` calls — one per section insertion — adds up. The right approach for index canvases: build the full markdown string client-side and create the canvas in a single `conversations.canvases.create` call. For ongoing sync, use `canvases.sections.lookup` with `contains_text` to find the target heading, then `canvases.edit` to insert or replace content around that section. ## What breaks when you force a full conversion Four things break first: metadata, permissions, version history, and link continuity. ### Metadata loses structure **Box metadata instances** are custom key-value pairs attached to files, often enforcing strict schemas (e.g., `status: Approved`, `retention_date: 2028-06-01`, `assigned_counsel: J. Smith`). These are stored as template-scoped entries and retrieved via `GET /files/{file_id}/metadata/{scope}/{templateKey}`. ([developer.box.com](https://developer.box.com/reference/get-files-id-metadata/)) Slack Canvas has no metadata engine. The template definitions, field types, and cascading policies do not transfer. You have two choices: 1. **Write the metadata into the index canvas** as plain text alongside each file link. This preserves the information for humans but loses the structured, queryable nature of Box metadata. 2. **Discard it.** If the metadata was only used for Box Relay workflows, retention policies, or classification — features that do not exist in Slack — the values may have no post-migration audience. For teams that heavily use metadata templates for compliance (document classification, retention schedules, legal holds), leaving files in Box is not just the easy path — it is the correct one. Box metadata is a feature of Box. Moving files out destroys it. ### Permissions stop lining up **Box collaborations** are per-folder (or per-file) permission grants. Each collaboration specifies a user or group, a role (viewer, editor, co-owner, previewer, etc.), and an invitation status. You list them via `GET /folders/{folder_id}/collaborations`. Permissions cascade downwards — access to a parent folder grants access to its children. ([developer.box.com](https://developer.box.com/ja/reference/resources/collaboration?utm_source=openai)) Slack Canvas access works differently depending on the [canvas type you choose](https://clonepartner.com/blog/blog/slack-canvas-api-channel-vs-standalone-for-document-migrations). A **channel canvas** inherits permissions from the channel it belongs to — every channel member can view it, and write access can be set separately. A **standalone canvas** has its own access list, managed via `canvases.access.set`. The mapping is not one-to-one: | Box concept | Slack equivalent | Gap | |---|---|---| | Folder collaboration (viewer) | Channel member | Box viewers see only that folder; Slack members see everything in the channel | | Folder collaboration (editor) | Canvas write access | Granularity lost — Canvas has read or write, not editor/co-owner/previewer | | Group collaboration | Slack user group + channel invite | Box groups ≠ Slack user groups; must be rebuilt | | External collaboration | Slack Connect | Requires Slack Connect, different licensing | | Inherited permissions (subfolder) | No equivalent | Canvas has no hierarchy, no inheritance | The practical approach: map each top-level Box folder to a Slack channel. Pull the collaboration list, match Box users to Slack users by email, and invite them to the channel. Accept that you are flattening a multi-level permission tree into a single channel membership list. Document what was lost. Do not attempt to map granular, file-level Box permissions into Slack. It is an administrative nightmare. Group content by audience and secure it at the channel level. **External collaborator resolution:** Box guest accounts — users who have access to specific folders or files without full Box accounts — present a specific problem. Your options are: 1. **Invite to Slack Connect.** If the external party has a Slack workspace, a Slack Connect channel preserves collaboration without requiring a full Slack account. This requires a Business+ or Enterprise Grid plan. 2. **Create Slack guest accounts.** Slack supports single-channel and multi-channel guests on paid plans. These cost less than full seats but add administrative overhead. 3. **Leave their files in Box.** If the external collaborator's access is limited to a bounded set of files, keep those files in Box and give them Box-only access. Do not migrate files that external parties depend on if those parties will not have Slack access. The right answer depends on the volume of external collaborators and whether Slack Connect is available on your plan. For most organizations, option 3 — leave externally-shared files in Box — is the least disruptive path. ### Version history collapses Box file objects expose `file_version` and version numbers via the versions endpoint. Slack Canvas can link or unfurl files, but it does not recreate Box version lineage as native canvas sections. If auditability or formal revision history matters, keep the file in Box and link to it from the canvas. ### Shared links break Every Box shared link uses a Box-specific URL structure: `https://app.box.com/s/{hash}` for shared links, `https://app.box.com/file/{id}` for direct file links, `https://app.box.com/folder/{id}` for folder links. These URLs resolve only while the Box account is active and the sharing settings are intact. **If you are keeping Box** (which, for most estates, you should), this is not an issue. The index canvas links back to Box, and Box continues resolving those URLs. The canvas is purely additive — a discovery layer on top of existing infrastructure. **If you are decommissioning Box**, you need to: 1. **Audit every outbound shared link.** Box's admin console can report on shared links, but there is no API endpoint for "list every shared link in the enterprise" — you have to walk folders and check each item's `shared_link` field in the items response. 2. **Download the files and upload them to Slack** (or another permanent host). 3. **Update every external reference.** Shared links embedded in emails, wikis, CRM records, and partner portals cannot be updated from your side. You will spend weeks fielding broken link reports. This is the single strongest argument for keeping Box as the file store and using Canvas only as a navigation layer. The cost of breaking shared links almost always exceeds the cost of maintaining a Box subscription. If link integrity is critical, read our guide on [migrating images, attachments, and embeds without broken links](https://clonepartner.com/blog/blog/how-to-migrate-images-attachments-embeds-without-broken-links). ## Step-by-step: Building the index canvas ### 1. Enumerate the Box folder tree Start from the root folder (ID `0`) or a designated top-level folder and recursively walk using `GET /2.0/folders/{folder_id}/items` with marker-based pagination. Store folder paths, file IDs, names, `modified_at` timestamps, and shared link URLs. ### 2. Collect metadata and collaborations For each file or folder, fetch metadata instances via `GET /files/{file_id}/metadata` and collaborations via `GET /folders/{folder_id}/collaborations`. Store what you need for the index — typically document owner, last modified date, and key classification fields. ### 3. Map Box users to Slack users Match Box collaborators to Slack workspace members by email address using the Slack `users.lookupByEmail` method. Build a mapping table. Flag any Box users who do not have Slack accounts — their access will be lost unless you create Slack accounts or guest seats, use Slack Connect, or accept the gap. ### 4. Create Slack channels and invite members For each top-level Box folder that maps to a team or project, create a Slack channel (or use an existing one). Invite the mapped users. This replaces Box's folder-level collaboration model with channel membership. ### 5. Build the canvas markdown Transform the folder tree into a flat markdown document using the three-level flattening strategy (h1 = department, h2 = project, h3 = sub-section). Folder names become headings. Files become list items with links. Metadata values are appended as inline annotations. Apply the 90-day `modified_at` filter to omit stale files from the active index (link them to an archive section instead). ### 6. Create the channel canvas Use `conversations.canvases.create` with the `channel_id` parameter to attach the canvas to the channel. Pass the full markdown in a single call rather than making multiple edit calls. This is faster and avoids `canvas_editing_locked` errors from concurrent operations. ```python import requests slack_token = "xoxb-your-bot-token" channel_id = "C0123ABCDEF" markdown_body = """# Engineering\n\n## Backend\n- [API Docs (PDF)](https://app.box.com/s/abc123) — Owner: jsmith, Updated: 2025-11-01\n""" response = requests.post( "https://slack.com/api/conversations.canvases.create", headers={"Authorization": f"Bearer {slack_token}"}, json={ "channel_id": channel_id, "document_content": { "type": "markdown", "markdown": markdown_body } } ) # Handle rate limiting if response.status_code == 429: retry_after = int(response.headers.get("Retry-After", 60)) # Sleep for retry_after seconds, then retry with exponential backoff elif not response.json().get("ok"): error = response.json().get("error") # Handle canvas_editing_locked, channel_not_found, etc. ``` ### 7. Upload files that are leaving Box For the subset of files being moved out of Box (not just indexed), use Slack's `files.getUploadURLExternal` → upload → `files.completeUploadExternal` flow. Update the canvas links to point to the Slack file permalinks. ### 8. Convert qualifying documents to standalone canvases For the small number of text-native, actively edited documents that passed the conversion filter, parse their content into markdown. For Box Notes, walk the JSON `doc` tree described in the Box Notes section above, emitting markdown for each node type. Create standalone canvases using `canvases.create` and link to them from the index canvas. ### 9. Set up sync for ongoing drift The index canvas is a point-in-time snapshot the moment you create it. Files get renamed, moved, and deleted in Box. To keep the index current, subscribe to Box webhook events: - **`FILE.MOVED`** — file relocated to a different folder; update or remove the canvas link - **`FILE.RENAMED`** — file name changed; update the display text in the canvas link - **`FOLDER.RENAMED`** — folder name changed; update the corresponding heading in the canvas - **`FILE.TRASHED`** / **`FILE.DELETED`** — file removed; remove the canvas link or flag as archived - **`COLLABORATION.REMOVED`** — collaborator access revoked; remove or flag the affected channel member For each event, use `canvases.sections.lookup` with `contains_text` to locate the affected heading or list item, then `canvases.edit` to replace the section. Without this sync layer, your index will diverge from Box within weeks of creation. ## What you are really deciding This is an architecture decision, not a migration decision. Box and Slack Canvas are not competing products. They are different tools for different jobs. The teams that get this right do not ask "how do we move everything from Box to Canvas." They ask "how do we make our Box files discoverable from inside Slack, where our team already works." ### Decision tree ``` Does the file pass all three conversion criteria? (text-native AND modified within 90 days AND single-channel audience) │ ├─ No → Is the file actively shared with external collaborators? │ ├─ Yes → Keep in Box. Do not migrate. │ └─ No → Is Box being decommissioned entirely? │ ├─ No → Link from canvas index. Keep in Box. │ └─ Yes → Upload to Slack (if under plan storage limit) │ or migrate to SharePoint/alternative storage. │ └─ Yes → Is it a Box Note or other text document? ├─ Box Note → Parse JSON, convert to Canvas markdown, create standalone canvas. └─ Other text doc (DOCX, etc.) → Extract text, convert to markdown, create standalone canvas. Flag formatting loss for review. ``` ### When to keep Box vs. when to cut over | Scenario | Recommendation | |---|---| | Team uses Box primarily for file storage (PDFs, Office docs, design assets) | Keep Box. Use Canvas as index only. | | Organization needs metadata templates for compliance | Keep Box. Metadata does not survive migration. | | Extensive external sharing via Box links | Keep Box. Link breakage cost is too high. | | Box Relay workflows or Shield classification in use | Keep Box. These features have no Slack equivalent. | | Files requiring HIPAA or FINRA compliance controls (Box Governance) | Keep Box. Slack is not a substitute for enterprise content governance. | | Small team with < 500 files, mostly text docs, no external collaborators | Consider full migration if Box subscription is not cost-justified. | | Box used by one team; rest of org lives in Slack; no external collaborators | Build index canvas, upload critical files to Slack (verify plan storage), evaluate Box renewal at next cycle. | | Plan is Slack Pro with 5 GB storage limit | Keep Box unconditionally for any estate beyond a handful of small files. | If your organization relies heavily on Box Governance for HIPAA or FINRA compliance, uses complex metadata templates to drive automated retention policies, or stores files exceeding Slack's plan-based storage limits, migrating that data into Slack is a mistake. Slack is a collaboration hub, not an enterprise content management system. If you are proceeding with a full migration to consolidate licenses — moving away from Box entirely alongside a [Quip to Slack Canvases migration](https://clonepartner.com/blog/blog/quip-to-slack-canvases-migration-the-official-salesforce-path) — ensure you have a dedicated cloud storage alternative like SharePoint mapped out for the heavy files that Slack cannot absorb. For that path, see our [Box to SharePoint migration guide](https://clonepartner.com/blog/blog/box-to-sharepoint-migration-permissions-box-notes-metadata). ## Common failure modes - **Canvas size limits.** A single canvas holds 1 MiB of markdown. For an enterprise with thousands of files, one monolithic index canvas will not work. Split by department or team — one canvas per channel. (If you are generating thousands of these, you will need a strict [naming and indexing strategy](https://clonepartner.com/blog/blog/naming-indexing-10000-slack-canvases-after-migration).) - **Heading depth.** Teams with 5+ levels of folder nesting will lose structural fidelity. Accept the flattening or create separate canvases for deep sub-trees. - **Stale links.** If files move within Box after the index is created, the canvas links break silently. Subscribe to `FILE.MOVED`, `FILE.RENAMED`, and `FOLDER.RENAMED` Box webhook events and update the canvas accordingly. - **User mismatch.** Box users who do not exist in Slack lose access entirely. This is especially common with external collaborators who had Box guest accounts but do not have Slack Connect access. Resolve this before migration using the `users.lookupByEmail` matching step. - **Rate limit cascades.** Hitting Box's 429 limit on enumeration, then immediately hitting Slack's Tier 2 limit on canvas creation, can turn a 4-hour job into a 12-hour crawl. Budget time for backoff on both sides, and implement `Retry-After` header handling on both the Box and Slack clients. - **Pro plan storage ceiling.** On Slack Pro, the 5 GB workspace storage limit is hit quickly if you begin uploading Box files to Slack-native storage. Audit your plan before uploading anything. - **Box Notes conversion failures.** Embedded file previews, @mentions, and comment threads in Box Notes have no Canvas equivalent. Log these as conversion warnings and include a "see original" link back to the Box Note for manual review. > Need help building index canvases for your Box estate, or figuring out which files should actually move? We build migration and integration pipelines — including hybrid patterns where the answer is "do not migrate everything." Book a 30-minute scoping call and we will map it out. > > [Talk to us](https://clonepartner.com/talk-to-us?duration=30&utm_source=blog&utm_medium=button&utm_campaign=demo_bookings&utm_content=cta_click&utm_term=demo_button_click) ## Frequently asked questions ### Can you migrate Box files to Slack Canvas? Only text-native content (runbooks, process docs, wiki pages) can be meaningfully converted to Canvas markdown. Binary files like PDFs, DOCX, and spreadsheets have no Canvas representation and should stay as files — either in Box or uploaded to Slack directly. ### Does Slack Canvas support folders? No. Slack Canvas has no folder concept, no nested containers, and no folder-level permissions. The only structural tool is headings (h1, h2, h3), which gives you three levels of hierarchy maximum. ### What is the Box API rate limit for migration? Box enforces 1,000 general API requests per minute per user. Uploads are capped at 240 per minute per user. Search is limited to 6 per second and 60 per minute per user. Rate limits apply per impersonated user when using As-User headers. ### What happens to Box metadata when you migrate to Slack? Box metadata templates and instances are Box-specific constructs with no equivalent in Slack. Metadata values can be written into a Canvas as plain-text annotations, but you lose the structured, queryable, and policy-driven nature of Box metadata. ### Do Box shared links keep working after migration? Box shared links use Box-specific URLs that stop resolving if you decommission your Box account. There is no redirect mechanism between Box and Slack. Keeping Box active and using Canvas as a navigation index avoids the problem entirely.