Top Unthread Alternatives (2026): Features, TCO & Migration

Top Unthread Alternatives (2026): Features, TCO & Migration

Unthread is a Slack-native, AI-powered helpdesk built for internal support and B2B customer support via Slack Connect. If you're reading this, you've hit one of its edges — pricing opacity, channel limitations, or scale constraints — and need to understand what else exists, what it costs, and what moving your data actually involves.

Unthread's public pricing starts at $50/agent/month for Basic and $75/agent/month for Pro on annual billing, both with a 5-seat minimum. That means the cheapest Unthread deployment is $250/month before you've resolved a single ticket. The real bill when switching, though, isn't the new platform's license — it's the data translation, workflow rebuilds, and channel cutover.

This guide covers seven Unthread alternatives in 2026, organized by architecture: Slack-native ticketing, B2B customer support platforms, and enterprise ITSM. Each section includes verified pricing, honest trade-offs, and migration complexity so you can pick the right tool without a three-month evaluation cycle.

Why Teams Leave Unthread

Unthread does one thing well: it turns Slack messages into structured, tracked tickets with AI automation. But the reasons teams outgrow it follow predictable patterns:

• Pricing opacity. Unthread's Pro plan is listed at $75/agent/month on some sources, but the company has moved toward custom/quote-based pricing on its own site. That makes budgeting harder for growing teams.
• Channel coverage. Unthread added Microsoft Teams, email, and web chat support, but its core architecture remains Slack-first. Teams where a significant share of requests originate outside Slack hit friction.
• No ITSM depth. No CMDB, no asset management, no formal change management. Teams maturing into ITIL-aligned processes need a different tool.
• Omnichannel B2B gaps. Unthread works for Slack Connect-based B2B support but lacks inbox depth for WhatsApp, Discord, and in-app chat widgets that dedicated B2B platforms provide.
• No self-serve trial. You can't evaluate Unthread without talking to sales.

Note: these patterns reflect migration intake data from our client base and publicly available G2 review themes. They are directional, not statistically representative of all Unthread users.

What to Evaluate in an Unthread Alternative

Before comparing vendors, lock down your actual requirements:

• Primary channel. Is Slack your only intake channel, or do you need email, Teams, portal, chat widget, or social?
• Internal vs. external support. Are you handling employee requests, B2B customer requests, or both? (If you are a B2C brand evaluating ticketless omnichannel platforms, see our Gladly vs Unthread technical comparison).
• ITSM maturity. Do you need SLAs and routing only, or full incident/problem/change management?
• AI pricing model. Per-resolution fees, per-agent add-ons, or AI included in the base plan at a specific tier?
• Data portability. Does the target platform have a write API that accepts historical ticket imports, or are you starting fresh?

Choosing an alternative also requires navigating two fundamentally different architectural paths. You can migrate to another Slack-native platform to preserve the conversational UI, or you can transition to an omnichannel or ITSM platform that treats Slack as just one of many ingress points.

With Slack-native tools, the source of truth for conversation data remains Slack's thread_ts and channel_id — you're primarily transferring metadata (ticket status, tags, assignee, SLA timers). With omnichannel tools, you're changing the data model entirely: extracting conversational history from Slack, resolving Slack user IDs to email addresses, and injecting data into a traditional ticket-based schema. The operational burden of these two paths differs by an order of magnitude.

Migration Complexity Matrix

Before diving into individual platforms, here is a structured comparison of what each migration from Unthread actually involves:

Target Platform	Import API Quality	Rate Limit (imports)	Data Model Delta vs. Unthread	Identity Resolution Burden	Attachment Handling	Overall Complexity
Thena	REST API (no bulk importer)	Not publicly documented	Low — both Slack-native	Low — shared Slack user IDs	Slack-hosted, re-host required	Medium
ClearFeed	Limited public API	Not publicly documented	Low — both Slack-native	Low — shared Slack user IDs	Slack-hosted, re-host required	Medium
Suptask	Supports data import	Not publicly documented	Low — both Slack-native	Low — shared Slack user IDs	Slack-hosted, re-host required	Low–Medium
Pylon	No documented bulk import API	Coordination with Pylon team required	High — account-centric model	High — Slack ID to email required	Re-host required + URL rewrite	High
Plain	GraphQL mutations only	Not publicly documented	High — timeline event model	High — Slack ID to email required	Re-host required + URL rewrite	High
JSM	REST API + CSV bulk import	Varies by Cloud plan	Medium — flat → hierarchical	Medium — Slack ID to email required	Separate upload endpoint	Medium–High
Freshservice	Ticket import API	50 req/min (lower tiers)	Medium — flat → ITSM hierarchy	Medium — Slack ID to email required	Standard attachment upload	Medium–High

Reading the matrix: "Data model delta" measures how structurally different the target's schema is from Unthread's conversation-first model. Low delta = the same Slack thread maps cleanly to the new ticket model. High delta = you must decompose Slack conversations into account records, timeline events, or issue hierarchies before import.

AI Cost Projection by Platform

The seat price is what teams budget. The AI price is what surprises them. Across the platforms in this guide, AI is either included at a specific tier (with undisclosed volume caps), sold as a per-resolution fee, or sold as a flat per-agent add-on. Here is what each model costs at scale:

Platform	AI Pricing Model	1,000 resolutions/mo	5,000 resolutions/mo	10,000 resolutions/mo
Unthread	Included in Pro ($75/agent/mo); Basic excludes AI	Seat cost only	Seat cost only	Seat cost only
Thena	Included from Standard ($79/user/mo)	Seat cost only	Seat cost only	Seat cost only
ClearFeed	Included in paid plans	Seat cost only	Seat cost only	Seat cost only
Suptask	Limited AI; no per-resolution model	Seat cost only	Seat cost only	Seat cost only
Pylon	AI add-on (pricing not publicly listed)	Seat + add-on	Seat + add-on	Seat + add-on
Plain	Usage credits (contact for pricing)	Variable	Variable	Variable
JSM	Included in Premium ($51/agent/mo); not in Standard	Seat cost only at Premium	Seat cost only at Premium	Seat cost only at Premium
Freshservice	Freddy AI Copilot: $29/agent/mo add-on (Pro+ only)	+$29/agent/mo	+$29/agent/mo	+$29/agent/mo
Intercom (reference)	Fin: $0.99/resolution	~$990/mo	~$4,950/mo	~$9,900/mo
Zendesk (reference)	Copilot: add-on fee on top of seat	Add-on	Add-on	Add-on

Key observation: For platforms that include AI in the seat price (Unthread Pro, Thena Standard, ClearFeed, JSM Premium), per-resolution economics improve as volume grows — the marginal cost of AI resolution is zero. For per-resolution models like Intercom's Fin, a 10,000-resolution month costs nearly $10,000 in AI fees alone, independent of seat count. Model this against your actual resolution volume before signing.

Volume caps on "included" AI plans are often undisclosed. Request explicit cap documentation from vendors before assuming unlimited AI coverage.

SLA Timer Edge Cases on Historical Import

The SLA timestamp problem is the most commonly underestimated technical risk in any helpdesk migration. It deserves its own structured treatment.

When you import a historical closed ticket into a new platform, you are injecting records with a created_at timestamp from the past — sometimes months or years ago. If the target platform's SLA engine evaluates breach status on import rather than on ticket creation, it will immediately flag every migrated ticket as a massive SLA breach and potentially fire notifications, escalations, or dashboard alerts.

Scenario	Risk	Mitigation
Importing closed tickets with past created_at	SLA engine fires breach on import	Set SLA policies to exclude imported ticket types, or import in a suspended state
Importing open tickets with past created_at	SLA timers start mid-breach	Pause SLA policies during import window, manually validate after cutover
Missing closed_at timestamp on closed tickets	Platform may treat ticket as open, triggering SLA	Ensure every closed record includes explicit closed_at in the API payload
Historical tickets in "Snoozed" state	Target may not support equivalent state	Map to "Pending" or "On Hold" with a note preserving original snooze context

Platform-specific SLA import behavior:

• Zendesk: Explicitly documents that imported tickets should be excluded from SLA and metric reporting. Requires ticket_import: true flag in the API payload to suppress SLA evaluation.
• JSM: SLA policies apply to all issues by default; imported issues require manual SLA exclusion rules pre-configured before bulk import begins.
• Freshservice: SLA timers activate on creation; use the API's skip_sla parameter (where available) or pre-suspend SLA policies.
• Plain: No SLA engine in the traditional sense — timeline events are stamped as created; no breach logic fires on import.
• Pylon: Coordination required with their team; no documented SLA import behavior.

Treat SLA configuration and data import as sequentially dependent steps, not parallel workstreams.

Slack-Native Alternatives

Thena — Closest B2B Slack-Native Competitor

What it is: A Slack-integrated B2B customer support platform with AI agent capabilities, focused on customer-facing support in shared Slack channels.

Pricing: Starter at $29/user/month (annual, up to 5 seats, 1,000 tickets/month), Standard at $79/user/month (adds AI auto-responses, co-pilot, API access, webhooks, web chat), Enterprise at $119/user/month (adds Teams support, custom AI deployments).

Key differentiators vs. Unthread:

• Self-serve signup — evaluate without a sales call
• AI agent studio with MCP integration on Standard tier
• Bidirectional sync with CRMs including Zendesk, HubSpot, and Salesforce
• Customer-facing B2B focus vs. Unthread's internal-support emphasis
• Clients include Branch, Mixpanel, and Workramp

Trade-offs: The Starter tier caps at 5 seats and 1,000 tickets/month — you will outgrow it quickly. Microsoft Teams support is Enterprise-only at $119/user/month, a 51% premium over Standard. API access is restricted to Standard and above, which creates friction for teams that need programmatic integrations early. AI is included from Standard tier ($79/user/month) — not available on Starter.

Migration path from Unthread: Because both platforms use Slack as the conversational datastore, you don't need to migrate the underlying Slack messages. You must export Unthread's ticket metadata (status, assignee, tags, linked channel IDs, thread timestamps) and map it to Thena's schema via their API. Budget for an API-led migration — there is no one-click Unthread importer. The primary risk is the cutover event: ensuring no messages are dropped during the minutes when the Unthread bot is removed and the Thena bot is authorized. Shared Slack user IDs mean identity resolution is minimal compared to omnichannel migrations.

For more on Thena's competitive landscape, see Top Thena Alternatives (2026): Features, TCO & Migration.

ClearFeed — Slack-to-Helpdesk Bridge

What it is: A Slack-native support platform that works as either a standalone helpdesk or a bidirectional bridge connecting Slack to an existing system like Zendesk, Jira, Salesforce, or Freshdesk.

Pricing: The Helpdesk edition starts at $24/agent/month, with a usage-based option at $40/month. The Integration edition (Slack-to-external-helpdesk bridge) is priced separately.

Key differentiators vs. Unthread:

• Bidirectional sync with Zendesk, Jira, Salesforce, HubSpot, and Freshdesk — Unthread doesn't natively sync into another helpdesk as a bridge layer
• Deep integration with Jira and GitHub for engineering escalation paths
• Triage channels in Slack where requests are aggregated and routed
• AI agents included, with SLA alerts visible in Slack
• Approval workflows with audit logs
• Unlimited agents on some plans (Unthread charges per-agent on every tier)

Trade-offs: ClearFeed's strength as a bridge means it sometimes adds a layer rather than replacing one. If you're going all-in on a standalone tool, you may end up running two systems. The AI capabilities, while solid, are less opinionated than Unthread's agentic approach — you configure more, and the system infers less.

Migration path from Unthread: No native import exists. Extract data via the Unthread API and push into ClearFeed. The main challenge is mapping Slack user IDs to ClearFeed's agent model — but because ClearFeed is also Slack-native, shared Slack IDs reduce the identity resolution burden compared to migrations to Pylon or Plain. For teams also syncing into Zendesk or Jira via ClearFeed, the target system's import API becomes the bottleneck. Most engineering teams opt for a "clean break" approach — migrating only open tickets and archiving historical Unthread data in a data warehouse.

Suptask — Lightest-Weight Slack Ticketing

What it is: A Slack-native ticketing system focused on simplicity. Emoji reactions or slash commands create tickets; agents triage and resolve without leaving Slack.

Pricing: Free plan (10 tickets/month), paid plans from $15/agent/month on annual billing. Custom plans available for 50+ users.

Key differentiators vs. Unthread:

• Significantly cheaper entry point ($15 vs. $50–75/agent/month)
• Free plan for evaluation — Unthread has no self-serve option
• Multi-inbox routing separates IT, HR, and Finance queues
• Private DM ticketing for sensitive requests
• Integrations with Jira, Zendesk, GitHub, GitLab, Salesforce

Trade-offs: Suptask is not an ITSM platform. No CMDB, no asset management, no change management. AI capabilities are limited compared to Unthread's agentic approach. For teams processing more than a few hundred tickets/month with complex routing, Suptask's simplicity becomes a constraint rather than an asset.

Migration path from Unthread: Suptask supports data imports. Extract from Unthread's API, map to Suptask's ticket schema, and load. This is the structurally simplest migration in this guide: both systems are Slack-native, share Slack user IDs as a common key, and have comparable flat ticket models. The lowest-complexity migration path for teams whose primary requirement is cost reduction without changing the Slack-based workflow.

B2B Customer Support Alternatives

Pylon — Purpose-Built B2B Omnichannel

What it is: An AI-native B2B customer support platform that unifies Slack Connect, Microsoft Teams, email, chat widget, WhatsApp, Discord, and forms into a single inbox.

Pricing: Starter at $59/seat/month, Professional at $89/seat/month, Enterprise at $139/seat/month (all annual). 3-seat minimum on Starter/Professional, 7-seat minimum on Enterprise. AI add-ons priced separately and not publicly listed. No free plan or standard free trial. Minimum committed spend: ~$2,124/year on Starter at 3 seats before AI add-ons.

Key differentiators vs. Unthread:

• Native Slack Connect support with threading and context preserved
• Account Intelligence dashboards with health scoring across support, success, and sales
• Omnichannel coverage (WhatsApp, Discord, Telegram) that Unthread lacks
• SOC 2, GDPR, ISO 27001 compliance, with HIPAA support when configured
• Data model built around Customer Contact (by email domain) and Account — a traditional B2B CRM structure that enables cross-channel customer history

Trade-offs: Pylon is a replacement, not an add-on layer. It does not integrate with Zendesk, Freshdesk, or Intercom — you are migrating to it. The seat minimums and absence of a free trial mean a minimum committed spend before production validation. For internal support (IT, HR), Pylon is architecturally overbuilt; it is designed for customer-facing B2B workflows. AI add-on pricing is not publicly listed, making TCO modeling incomplete without a direct sales engagement.

Migration path from Unthread: This is the highest-complexity migration in this guide. Unthread organizes around Slack conversations and internal team routing; Pylon organizes around customer accounts and omnichannel threads. Every conversation needs account-level attribution (email domain mapping) that may not exist in Unthread's data model. You must:

1. Extract ticket metadata from Unthread's REST API
2. Extract message payloads from Slack's conversations.history endpoint
3. Resolve Slack user IDs to email addresses via users.info
4. Convert Slack's proprietary blocks format into standard HTML or Markdown
5. Attribute each conversation to a Pylon Account record (requires pre-building the account hierarchy)
6. Coordinate import with Pylon's team — no documented bulk import API exists

No documented bulk import API means migration timeline is partially outside your control.

For a broader look at the B2B omnichannel market, see Top Pylon Alternatives in 2026: TCO, Features & Migration Paths.

Plain — Developer-First API Helpdesk

What it is: An API-first, GraphQL-powered support platform. Plain doesn't force you into a specific UI paradigm — while it offers a default interface and Slack integrations, its core value is programmatic control over the support experience, enabling custom support UIs embedded directly in your product.

Pricing: Foundation at $35/month including 1 seat, Horizon at $299/month including 3 seats (adds Microsoft Teams, SLAs, knowledge base, CRM integrations, and reporting). AI usage is credits-based; contact for pricing. Plain's migration guide lists importers for Zendesk, Freshdesk, Intercom, Front, and Help Scout — Unthread is not on this list.

Key differentiators vs. Unthread:

• Everything is a GraphQL API — full programmatic control over ticket creation, updates, and queries
• Timeline-based data model: every interaction (email, Slack message, backend event, billing failure) is a timestamped event on the customer's chronological timeline, not a discrete ticket
• Built-in importers for major helpdesk platforms (not Unthread)
• Custom support UIs embedded directly in your product via SDK
• Per-seat pricing structure with no hidden platform fees (AI costs are separate)

Trade-offs: Plain requires sustained development investment. You are buying an API and a framework, not a turnkey helpdesk. The strict GraphQL typing means data validation is tight — malformed payloads are rejected at the API layer, not silently accepted. Plain explicitly states that workflows and automations are rebuilt, not imported. For non-engineering teams, the operational model is fundamentally different from Unthread's configured-no-code approach.

Migration path from Unthread: Unthread is not on Plain's supported importer list. Migration requires custom GraphQL mutations. The specific challenge is structural: Unthread's ticket model must be decomposed into Plain's TimelineEntry events, where each Slack message becomes a discrete dated event on a customer timeline. Steps:

1. Extract Unthread ticket metadata via REST API
2. Extract Slack thread messages via conversations.replies
3. Resolve Slack user IDs to email addresses
4. Create Customer records in Plain via GraphQL
5. Push each message as a TimelineEntry mutation with correct timestamps
6. Malformed attachments or unmapped user IDs cause GraphQL validation rejection — not soft failures

Plain recommends running a parallel pilot phase before cutover. Budget additional time for GraphQL schema validation failures during development.

Enterprise ITSM Alternatives

Jira Service Management — For Atlassian-Native Teams

What it is: Atlassian's ITSM platform with incident, problem, change, and asset management. Atlassian Assist (formerly Halp, retired as a standalone product June 2024) provides Slack and Teams-native ticket intake, but only as a JSM-integrated feature — not as a standalone tool.

Pricing: Free (up to 3 agents), Standard at $20/agent/month, Premium at ~$51/agent/month (annual billing). Enterprise is custom-quoted. Only agents are charged — requesters are free, which changes the per-seat math for large internal deployments. Marketplace apps (common additions: Insight for CMDB, automation add-ons) add to TCO and are not reflected in base pricing.

Key differentiators vs. Unthread:

• Full ITSM process framework: incident, problem, change, release management
• CMDB and asset management (Premium tier and above)
• Atlassian Assist provides Slack/Teams conversational intake similar to Unthread's model — but only when using JSM as the backend
• Deep integration with Jira Software, Confluence, and Bitbucket
• 400+ forms and templates out of the box

Trade-offs: JSM's real cost extends beyond list pricing — Marketplace apps, implementation, training, and premium support materially increase TCO. Atlassian Assist only works with JSM; if you're not in the Atlassian ecosystem, the Slack integration is significantly weaker than Unthread's native experience. Data Center is being phased out (new DC subscriptions end March 2026, EOL March 2029), pushing all remaining on-premise deployments to Cloud.

Migration path from Unthread: Export via Unthread's API, then import using JSM's REST API or bulk CSV import. The data model translation is the primary challenge: Unthread's flat conversation-to-ticket model must map to JSM's project → issue type → request type hierarchy. Every ticket needs explicit issue type and project assignment before it can be accepted. Custom fields must be pre-created in JSM before bulk import. Attachments require re-upload through a separate endpoint. SLA policies must be configured to exclude imported historical tickets before import begins (see SLA edge cases section above). Budget 2–4 weeks for a migration involving 10,000+ historical tickets with custom field mapping.

Freshservice — Mid-Market ITSM Without Atlassian Lock-In

What it is: A cloud ITSM platform from Freshworks with incident management, service catalog, change management, and asset management. Positioned as faster to deploy than ServiceNow and architecturally independent from any dev-tools ecosystem.

Pricing: Starter at $19/agent/month, Growth at $49, Pro at $99, Enterprise at $119 (all annual, billed per agent). Freddy AI Copilot is a $29/agent/month add-on available only on Pro and Enterprise tiers. Effective AI-inclusive pricing: Pro + Copilot = $128/agent/month, Enterprise + Copilot = $148/agent/month. 21-day free trial available.

Key differentiators vs. Unthread:

• Complete ITSM framework with ITIL process alignment
• Asset management and CMDB available from Growth tier
• Faster out-of-the-box setup than JSM — configuration-first rather than project-and-issue-type-first
• No ecosystem lock-in — works independently of any specific dev-tools stack

Trade-offs: The effective AI-inclusive cost ($128/agent/month at Pro) exceeds Unthread's Pro tier ($75/agent/month) by 71% for equivalent AI functionality. Slack integration exists but is not Slack-native — agents work in the Freshservice web interface. For teams whose operational workflows live in Slack, this represents a fundamental change in daily tool usage, not a configuration difference. The API rate limit of 50 requests/minute on lower tiers means bulk historical imports require rate-limit-aware batching logic — a 20,000-ticket migration at 50 requests/minute takes a minimum of 6+ hours of API time, excluding retries.

Migration path from Unthread: The Freshservice ticket import API accepts structured payloads. Custom fields must be pre-created in Freshservice before any import begins — the API rejects payloads referencing undefined field IDs. Rate limit awareness is mandatory for large imports: implement exponential backoff with jitter for HTTP 429 responses. SLA policies should be suspended or configured to exclude historical imports before the import run. The data model shift from Unthread's flat conversation model to Freshservice's incident/request hierarchy requires explicit type mapping for every ticket category.

Pricing Comparison: Unthread vs. Alternatives (Annual Billing)

Platform	Entry Tier	Mid Tier	AI Included?	AI Tier	Free Plan/Trial	Slack-Native?
Unthread	$50/agent/mo	$75/agent/mo (Pro)	Yes	Pro only	No	Yes
Thena	$29/user/mo	$79/user/mo	Yes	Standard+ ($79)	Self-serve signup	Yes
ClearFeed	$24/agent/mo	$40/mo (usage)	Yes	All paid plans	Free tier	Yes
Suptask	$15/agent/mo	~$39/agent/mo	Limited	Limited on paid	Free (10 tickets/mo)	Yes
Pylon	$59/seat/mo	$89/seat/mo	Add-on (unpublished price)	Add-on only	No	Partial (unified inbox)
Plain	$35/mo (1 seat)	$299/mo (3 seats)	Credits-based	All tiers (usage)	No	Partial
JSM	$20/agent/mo	$51/agent/mo	Yes	Premium only ($51)	Free (≤3 agents)	Via Assist add-on
Freshservice	$19/agent/mo	$99/agent/mo	$29/agent add-on	Pro+ only (+$29)	21-day trial	No

The Technical Reality of Migrating Off Unthread

Every Unthread migration shares the same structural challenge: Unthread's data model is Slack-conversation-first, and no target platform uses that same model. You are always translating.

What You're Exporting

Unthread's API is RESTful with JSON request/response bodies, API key authentication via X-Api-Key header, and cursor-based pagination at 100 records per page. Key entities to extract:

• Conversations (tickets) with status, priority, assignee, SLA data, and created_at/closed_at timestamps
• Messages within conversations, tied to Slack thread timestamps via thread_ts
• Customers, linked to Slack user IDs or email
• Custom fields and tags
• Attachments, stored as Slack file references (private, expiring URLs)

One critical constraint not widely documented: Unthread's API returns ticket metadata accurately, but message-level history for older threads may require supplementary calls to Slack's conversations.replies endpoint using the stored thread_ts. Verify whether your Unthread subscription tier and Slack plan preserve full message history — Slack's free tier retains only 90 days of message history, and older threads may not be recoverable regardless of what Unthread's API returns.

For a detailed walkthrough of export mechanics, see How to Export Data from Unthread: Methods, API Limits & Formats.

Slack Identity Resolution

This is the single most common migration bottleneck, and it compounds with scale. Unthread stores users by their Slack ID (e.g., U12345678). Every target platform outside the Slack ecosystem identifies users by email address. Your migration script must query the Slack users.info or users.list endpoint for every unique Slack user ID in your historical tickets and build a lookup table before any data transformation begins.

Slack's API enforces strict rate limits by method tier:

• Tier 1: 1 request/minute
• Tier 2: 20 requests/minute
• Tier 3: 50 requests/minute
• Tier 4: ~100 requests/minute — applies to users.info

For a migration involving 50,000 historical tickets referencing 10,000 unique users, identity resolution at Tier 4 limits requires a minimum of 100 minutes of API time for user lookups alone, before any deduplication or batching optimization. Implement caching: once a Slack user ID is resolved to an email, cache the result in a local lookup table and do not re-query. Implement retry logic with exponential backoff for HTTP 429 responses. For Slack-native-to-Slack-native migrations (Unthread to Suptask, ClearFeed, or Thena), this step is largely unnecessary since both systems operate on the same Slack user ID namespace.

Handling Slack Attachments

When a user uploads a file to an Unthread ticket in Slack, that file is hosted on Slack's CDN. The URL in the API payload is private and time-limited. Failure to re-host attachments during migration results in broken image and file links in your target platform within days of cutover. The process:

1. Intercept the attachment URL from the Unthread/Slack API response.
2. Make a GET request to Slack's file endpoint, passing a Bot User OAuth Token in the Authorization: Bearer header.
3. Download the binary to a temporary server.
4. Upload the binary to the target platform's file storage API.
5. Rewrite the URL reference in the ticket body or timeline entry to point to the new hosted location.

Attachment re-hosting is a sequential, per-file operation. For a corpus of 10,000 attachments at an average download/upload cycle of 3 seconds per file, this step alone requires approximately 8+ hours of processing time. Parallelize with thread pools and implement per-file error logging — partial failures are common and must be identified for retry, not silently skipped.

State and Workflow Mapping

Unthread's status model (Open, In Progress, Snoozed, Closed) must be mapped to the target platform's equivalents. The "Snoozed" state has no universal equivalent — map to "Pending" or "On Hold" with a preserved note containing the original snooze context and expiry timestamp.

SLA timer handling on import: See the dedicated SLA edge cases section above. This is not a minor detail — it is the most common cause of post-migration operational incidents.

Workflows and automations do not migrate — in any platform. Plain explicitly documents that workflows are rebuilt, not imported. Zendesk excludes imported tickets from SLA metric reporting by design. Treat data migration and workflow reconstruction as two separate workstreams with separate timelines and owners.

Target Platform Import Constraints Summary

Platform	Import Method	Pre-conditions	Key Constraint
JSM	REST API or CSV bulk	Issue types and projects pre-created; SLA policies suspended	Attachments via separate endpoint; hierarchy mapping mandatory
Freshservice	Ticket import API	Custom fields pre-created; SLA policies suspended	50 req/min rate limit on lower tiers
Pylon	No documented bulk API	Pylon team coordination required	Account hierarchy must be pre-built
Plain	GraphQL mutations	Customer records pre-created	Strict type validation — rejected payloads are not soft failures
ClearFeed	Limited public API	Custom scripting required	No native Unthread importer
Suptask	Data import supported	Minimal pre-conditions	Simplest migration path in this guide
Thena	REST API (no bulk importer)	Bot authorization cutover planning	No one-click importer; cutover timing is the primary risk

Decision Framework

Stay Slack-native for internal support → ClearFeed if you want a bridge to an existing helpdesk. Suptask if you want the lightest-weight, lowest-cost option. Both preserve the Slack-first experience and represent the lowest-complexity migrations in this guide.

B2B customer support via shared Slack channels → Pylon if you need full omnichannel coverage and account intelligence and can absorb a high-complexity migration. Thena if you want to stay closer to Slack with a lower entry price — but verify its long-term viability in writing before committing.

Developer-first support embedded in your product → Plain. Its GraphQL API and timeline-based data model are built for teams that want programmatic control. Budget for a higher-complexity migration and a pilot phase before cutover.

Growing into ITSM → JSM if your engineering team already lives in Atlassian and you can absorb Marketplace app costs. Freshservice if you want faster setup, no ecosystem dependency, and a 21-day trial. Both require leaving the Slack-native model behind — Atlassian Assist is a partial bridge, not a full substitute. Effective AI-inclusive cost for Freshservice ($128/agent/month) exceeds Unthread Pro by 71%.

Minimizing migration risk → Suptask and ClearFeed migrations from Unthread are structurally simplest because both systems share Slack as a substrate. Pylon and Plain migrations are the most complex because they require full data model translation, Slack identity resolution, and attachment re-hosting. JSM and Freshservice fall in the middle.

What Migration Actually Costs

The platform subscription is the number everyone fixates on. The migration cost is the number that catches teams off guard.

Migration complexity scales with three variables: ticket volume, custom field depth, and attachment count. The following ranges are based on internal project data from migrations we have completed — they reflect actual engineering hours, not theoretical estimates, and assume a team with working API familiarity on both sides:

Migration Scope	Ticket Volume	DIY Engineering Hours	Primary Time Driver
Small	<2,000 tickets, <5 custom fields, minimal attachments	20–40 hours	Schema mapping and API setup
Medium	2,000–10,000 tickets, 10–20 custom fields, moderate attachments	40–80 hours	Identity resolution + attachment re-hosting
Large	10,000–50,000 tickets, 20+ custom fields, high attachment count	80–160 hours	Rate limit management + data validation
Complex	Any volume migrating to Pylon or Plain	Add 30–50% to above	Data model decomposition + no bulk importer

Data validation is consistently underestimated. Confirming that every ticket, assignment, and SLA timestamp survived translation accounts for 30–40% of total migration effort across projects in this range. Teams that skip structured validation discover missing tickets, broken attachment links, and wrong assignee mappings weeks after cutover — when the Unthread access has been terminated and rollback is no longer possible.

Parallel running: Budget 2–4 weeks of running both systems simultaneously. This is not optional for migrations above the small tier.

The hidden TCO risk across all targets: AI pricing can outweigh seat pricing at scale. As shown in the AI cost projection table above, platforms with per-resolution fees become exponentially more expensive as volume grows. Model the AI spend separately from the seat cost and request explicit volume cap documentation from any vendor claiming "included AI."