---
title: "LiveChat vs Thena (2026): Architecture, TCO & Migration"
slug: livechat-vs-thena-2026-architecture-tco-migration
date: 2026-08-07
author: Rishabh
categories: [Help Desk, Migration Guide]
excerpt: "LiveChat vs Thena compared on architecture, pricing, APIs, and migration. Technical breakdown for teams choosing between website chat and Slack-native B2B support."
tldr: LiveChat is built for website-visitor chat (B2C/e-commerce); Thena is Slack-native B2B support. No native migration path exists — API-based migration requires data model translation between chat→thread→event and request→comment structures.
canonical: https://clonepartner.com/blog/livechat-vs-thena-2026-architecture-tco-migration/
---

# LiveChat vs Thena (2026): Architecture, TCO & Migration


# LiveChat vs Thena (2026): Architecture, TCO & Migration

> [!NOTE]
> **TL;DR:** LiveChat is a real-time, website-visitor-facing chat platform built for B2C and e-commerce. Thena is a Slack-native, AI-first B2B support platform that turns messaging-channel conversations into structured tickets. They solve different problems for different buyers. The deciding factor is almost always your primary support channel: website widget vs. Slack Connect. Migrating between them requires an API-based approach — no native import path exists, and the data models don't map 1:1.
>
> **Last verified:** June 2025 against LiveChat API v3.5 documentation and Thena Platform API documentation.

LiveChat and Thena occupy fundamentally different positions in the customer support stack, but they show up in the same evaluation cycles when teams outgrow one model and move toward the other. Teams moving from LiveChat to Thena are typically shifting from a B2C or transactional SaaS model to an enterprise B2B model where high-value customers demand direct access via Slack. Teams evaluating LiveChat are optimizing for website conversion, anonymous visitor triage, and high-velocity ticket deflection.

This guide breaks down architecture, data models, pricing, API constraints, compliance posture, and the exact migration path between them — with specific version numbers, rate limits, and transformation logic rather than feature-matrix summaries.

## LiveChat vs Thena: Who Each Platform Is Built For

**LiveChat** (by Text, Inc.) is a conversation-first live chat platform designed for real-time customer engagement on websites. Its architecture is fundamentally session-based: a visitor lands on a webpage, the JavaScript widget initializes, and a WebSocket connection opens. It's optimized for B2C support, e-commerce sales conversations, and front-line customer service where someone lands on your site and needs immediate help.

- **State Management:** Interactions are ephemeral until categorized. A user can be anonymous, identified via email, or authenticated via SSO.
- **Routing:** Built for speed. LiveChat uses round-robin, skill-based routing, and workload limits to distribute thousands of concurrent chats across large agent pools.
- **Ecosystem:** Heavily reliant on the Text ecosystem. For automation, you need ChatBot (separate product, $52+/mo annual). For async ticketing, you need HelpDesk (LiveChat's built-in ticketing was sunset on January 6, 2025). For self-service, you need KnowledgeBase. Each is a separately licensed product.

**Thena** (by Pivoting Owl Inc.) flips the model. Instead of asking customers to come to a website widget, Thena lives where B2B customers already work: Slack. It acts as an overlay on top of Slack Connect channels, turning unstructured chat into structured support requests using AI-powered request detection.

- **State Management:** Interactions are persistent. A Slack channel is tied to a specific customer account. Every message is inherently authenticated by the user's Slack workspace identity.
- **Routing:** Built for account management. Thena routes requests based on channel mapping, account ownership, and Slack user groups — often syncing state bi-directionally with Zendesk, Salesforce, or HubSpot.
- **Ecosystem:** Thena doesn't try to replace your CRM or core ticketing engine. It acts as the intelligent routing and engagement layer between Slack and your backend systems, with native integrations into Jira, Linear, and Salesforce for engineering escalation. Thena also supports Microsoft Teams (available on Enterprise tier) and Discord as intake channels, though the Teams integration is architecturally shallower than the Slack Connect implementation — it handles inbound messages but lacks the full bi-directional thread sync available in Slack.

| Dimension | LiveChat | Thena |
|---|---|---|
| **Primary channel** | Website chat widget | Slack Connect, MS Teams, Discord |
| **Data model** | Chat → Thread → Event | Request (ticket) → Comments, Account context |
| **Target buyer** | B2C, e-commerce, website-facing support | B2B SaaS, technical support, account-based CS |
| **Agent workspace** | Dedicated agent desktop app | Slack-native (agents work inside Slack) |
| **Visitor intelligence** | Real-time monitoring, page tracking, sneak peek | Account-level context, CRM sync |
| **AI approach** | ChatBot (separate product, $52+/mo annual) | Built-in AI agent studio, MCP (Model Context Protocol) server |
| **Ticketing** | HelpDesk (separate product since Jan 2025) | Native request/ticket system |
| **MS Teams support** | No | Enterprise tier only; limited bi-directional sync |

### When LiveChat Is the Right Choice

- You need a **website chat widget** with real-time visitor monitoring, proactive chat triggers, and pre-chat surveys
- Your support model is **B2C or e-commerce** — high volume, short interactions, sales-oriented
- You want **mature integrations** with Shopify, WooCommerce, and e-commerce platforms
- You need features like **sneak peek** (see what customers type before sending) and auto-greetings based on page URL, visit count, or time on site

### When Thena Is the Right Choice

- Your customers **already live in Slack** and you support them via Slack Connect channels
- You need **account-based support** — each customer is a company with multiple users, not anonymous website visitors
- You want tickets created **automatically from Slack messages** with AI-powered intent detection
- Your team prefers a **kanban-style board** over a traditional inbox
- You need native integrations with **Jira, Linear, and Salesforce** for engineering escalation
- You want to bridge the gap between engineering (Slack) and support (Zendesk/Salesforce)

### The Hybrid Scenario

A B2B SaaS company that runs both a public-facing marketing site and named-account Slack Connect channels has no clean single-platform answer. Running both LiveChat and Thena in parallel creates a data silo problem: chat history from the website widget is not visible when an agent opens the Slack channel for that account, and vice versa. The practical resolution is to pick the channel that handles the majority of your support volume and route the secondary channel into the primary system of record manually or via a lightweight Zapier/Make workflow. Neither platform offers a native bridge to the other.

## Architecture and Data Model Comparison

If you're planning a migration, you must understand how the two platforms structure data. You cannot force LiveChat's hierarchy directly into Thena.

### LiveChat's Data Model

LiveChat organizes data around the chat lifecycle:

- **Chat**: The top-level container. Each website visitor interaction creates a chat.
- **Thread**: A single session within a chat. A returning visitor creates a new thread under the same chat. If a chat goes idle and resumes, a new thread is created.
- **Event**: Individual messages, file transfers, system messages, or rich messages within a thread.
- **Customer**: Identified by email or a generated ID from the chat widget. No persistent account hierarchy.
- **Group**: Agent routing container (e.g., "Sales," "Support").
- **Tag**: Flat labels applied to chats for categorization.

For a deeper dive into LiveChat's export capabilities, see our guide on [How to Export Data from LiveChat](https://clonepartner.com/blog/blog/how-to-export-data-from-livechat-methods-api-limits-formats/).

### Thena's Data Model

Thena organizes data around the B2B account relationship:

- **Request**: The primary ticket object. Created from Slack messages, email, web chat, or forms. Carries status, priority, assignee, SLA, and custom fields.
- **Account**: The customer company. All requests roll up to an account with CRM-style metadata.
- **Team**: Internal grouping for routing and board management.
- **Comment**: Threaded replies on a request, synced bi-directionally with Slack threads.
- **Tag/Custom Field**: Flexible classification on requests.
- **External Link**: References to Jira issues, Linear tickets, or Salesforce records linked to a request.

Thena's Slack integration is bi-directional — a request created from a Slack message stays linked to that Slack thread, and updates flow both ways. This is the key architectural differentiator from traditional helpdesks that merely push notifications into Slack.

For specifics on getting data out of Thena, see our guide on [How to Export Data from Thena](https://clonepartner.com/blog/blog/how-to-export-data-from-thena-methods-api-limits-formats/).

### Entity Mapping

| LiveChat Entity | Thena Equivalent | Migration Constraint |
|---|---|---|
| Agent | Internal Slack User / Agent | Must map by email address. Unmapped agents will orphan data. |
| Customer | External Slack User / Contact (Account) | LiveChat customers without emails cannot be mapped to Thena. |
| Chat / Thread | Request / Ticket | LiveChat threads must be flattened into a single Thena Request. |
| Event (Message) | Threaded Comment | HTML formatting from LiveChat must be converted to Slack `mrkdwn`. |
| Group | Team | Manual mapping required. |
| Tag | Tag | Direct mapping. |

### Webhook and Event Stream Comparison

Both platforms expose event-based notifications, which affects real-time integration architecture significantly:

**LiveChat webhooks** are configured via the Configuration API v3.5. Supported event triggers include `incoming_chat`, `incoming_event`, `chat_deactivated`, `agent_status_changed`, and others. Webhooks are license-scoped and deliver to a single registered URL per action. There is no native webhook fan-out — if multiple integrations need the same event, you must build a relay layer.

**Thena webhooks** are configured through the App Platform API. Thena supports outbound webhooks on request creation, status changes, and comment additions. Events carry the full request object in the payload, reducing the need for follow-up API calls to reconstruct context. Thena's webhook delivery includes a retry mechanism on 5xx failures; LiveChat's retry behavior is not documented in public API references.

For teams evaluating real-time integration complexity — for example, syncing both platforms to a shared data warehouse — Thena's richer event payloads reduce integration code, while LiveChat's granular per-event triggers offer more control over which events are forwarded.

## Pricing and Total Cost of Ownership (TCO)

Direct price-per-seat comparisons are misleading without accounting for what each platform includes and excludes.

### LiveChat Pricing (2026)

| Plan | Annual (per agent/mo) | Monthly (per agent/mo) | Key Limits |
|---|---|---|---|
| **Starter** | $20 | $25 | 60-day chat history, 1 concurrent chat |
| **Team** | $41 | $49 | Unlimited history, unlimited agents |
| **Business** | $59 | $79 | Staffing prediction, SMS |
| **Enterprise** | Custom | Custom | HIPAA, SSO, custom tracking |

> [!WARNING]
> **Hidden cost: The Text ecosystem tax.** LiveChat alone only handles real-time chat. ChatBot is a standalone product starting at $52/month (annual billing), not included in any LiveChat plan. HelpDesk is a separate product for async email ticketing. KnowledgeBase is another add-on. A fully loaded tech stack with all three add-ons can reach $140–$180/agent/month before volume discounts — roughly 2.4–3x the baseline Business seat price.

### Thena Pricing (2026)

| Plan | Annual (per user/mo) | Key Limits |
|---|---|---|
| **Free** | $0 | Up to 10 users, 1,000 tickets/month |
| **Starter** | $29 | Up to 5 paid seats, 1,000 tickets/month, Slack + email |
| **Standard** | $79 | AI web chat, AI agent studio, MCP integration, API access |
| **Enterprise** | $119 | MS Teams, custom AI deployments, enterprise APIs |

> [!WARNING]
> **Hidden cost: Ticket caps and Slack infrastructure.** Thena's Starter plan caps at 1,000 tickets per month. High-volume B2B support teams can hit this in weeks, forcing an upgrade to Standard at nearly 3x the per-user price. Separately, to use Thena effectively across hundreds of B2B customers, you need Slack Connect at scale — which often pushes organizations toward Slack Enterprise Grid, a licensing cost entirely independent of Thena. Thena's own retention limits on Free and Starter tiers are not explicitly quantified in public documentation; confirm with Thena sales before assuming full historical access.

### TCO Scenario: 10-Agent Team

| Cost Component | LiveChat (Business) | Thena (Standard) |
|---|---|---|
| Seats (annual billing) | $590/mo (10 × $59) | $790/mo (10 × $79) |
| AI/Bot add-on | $52/mo (ChatBot) | Included (AI agent studio) |
| Ticketing | +$0–$50/mo (HelpDesk) | Included |
| **Estimated monthly** | **~$642–$692** | **~$790** |

Thena's higher per-seat cost includes AI and ticketing. LiveChat's lower seat price requires add-ons to match the feature set. At scale, the gap narrows or inverts depending on how many add-ons you need. Neither figure includes underlying infrastructure costs — Slack Enterprise Grid for Thena at scale, or the full Text ecosystem for LiveChat.

## Compliance and Data Residency

Enterprise buyers evaluating either platform for regulated industries need to assess security posture independently of feature comparisons.

**LiveChat compliance:**
- SOC 2 Type II certified
- GDPR-compliant data processing (data stored in US and EU regions; EU data residency requires Enterprise plan)
- HIPAA-compliant configurations available on Enterprise plan with a signed Business Associate Agreement (BAA)
- ISO 27001 certification maintained by Text, Inc.

**Thena compliance:**
- SOC 2 Type II certified
- GDPR-compliant
- HIPAA BAA availability: contact Thena sales — not documented as a standard plan feature as of June 2025
- Data residency: US-based by default; Enterprise customers should confirm regional storage options directly with Thena

**Practical implication:** For healthcare, financial services, or government customers subject to HIPAA or FedRAMP, LiveChat's Enterprise plan has a documented BAA pathway. Thena's compliance posture for regulated industries is less publicly specified. If compliance is a hard gate, verify both platforms' current certifications directly before beginning a migration project — compliance documentation changes on sales cycles, not calendar quarters.

## API Constraints: What You're Working With

Both platforms expose APIs, but the design, authentication, and rate limits differ significantly.

### LiveChat API

- **Current stable version**: v3.5 ([Agent Chat API docs](https://developers.livechat.com/docs/messaging/agent-chat-api/))
- **Authentication**: OAuth 2.1 Bearer tokens or Personal Access Tokens (PAT) via `accounts.livechat.com`
- **Base URL**: `https://api.livechatinc.com/v3.5/`
- **Rate limit**: 1,000 requests per 10-minute window per license, shared across all tokens and integrations on that license
- **Key constraint**: All operations (including reads) use HTTP POST with a JSON body — no GET endpoints with query parameters
- **Pagination**: Cursor-based for chat lists

### Thena API

- **Structure**: Platform APIs, App Platform APIs, Workflows APIs ([Thena API docs](https://docs.thena.ai/))
- **Authentication**: API key via `x-api-key` header, generated from Dashboard → Organization Settings → Security and Access
- **Base URL**: `https://platform.thena.ai/v1/`
- **Rate limit (Standard)**: 60 requests per minute per user, org, and IP
- **Rate limit (Enterprise)**: Custom

> [!CAUTION]
> **Thena API access requires Standard tier.** API access is gated to the Standard plan ($79/user/mo) and above. Starter plan users have no API access — only manual dashboard exports in XLSX or JSON format. This is a hard gate, not a rate-limit difference. Plan your migration (or integration) accordingly.

### Rate Limit Impact on Migration

LiveChat's 1,000 requests per 10 minutes (~1.67 req/sec sustained) is reasonable for bulk extraction, but that quota is shared across all tokens and integrations on the license. If other integrations (chatbots, analytics tools) are running concurrent API calls during extraction, your migration script competes for the same pool.

Thena's 60 requests per minute (~1 req/sec) is tighter and will bottleneck large loads. For 10,000 chats with an average of 5 messages each, you're generating approximately 60,000 API calls — roughly 17 hours at standard tier limits before retries and error handling are factored in. In practice, a 10–15% error-and-retry rate is typical for migrations of this scale, pushing total wall-clock time to 19–20 hours on a clean run. Run migrations during off-hours or temporarily disable other API consumers to avoid rate limit collisions on the LiveChat extraction side.

## Migration Path: LiveChat → Thena

> [!WARNING]
> **No native import exists.** There is no one-click migration path from LiveChat to Thena. No third-party migration tool currently offers a verified connector for this pair. You must extract data via LiveChat's Agent Chat API, transform the payloads, and load them into Thena's infrastructure (or your connected backend like Zendesk) via REST APIs.

Because Slack does not allow external applications to backdate messages or impersonate user accounts in a channel, **you cannot migrate historical LiveChat conversations directly into Slack channels.** Historical LiveChat data must be migrated into Thena's web dashboard or your underlying system of record as closed, archived requests. This provides agents with historical context without polluting active Slack channels.

### Step 1: Extract from LiveChat

Use the Agent Chat API v3.5 to pull all historical chats:

```bash
curl -X POST https://api.livechatinc.com/v3.5/agent/action/list_chats \
  -H "Authorization: Bearer <YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"limit": 25, "sort_order": "desc"}'
```

For each chat, extract all threads and events. Paginate using the returned cursor. Implement a request counter with proactive pausing at ~900 requests per 10-minute window — not just reactive 429 handling — to stay within the shared rate limit.

**Extraction constraints:**
- Iterate through date ranges rather than querying full history in a single call — large unbounded queries time out.
- **LiveChat Starter limits chat history to 60 days.** Data older than 60 days is inaccessible via both the UI and the API on this plan. Upgrade to Team ($41/agent/mo annual) before starting extraction if you need full history. This cannot be retroactively recovered after downgrade or cancellation.
- The Reports API provides aggregated analytics data useful for metrics reconstruction but does not contain record-level message content suitable for migration. CSV exports from the Archives section give basic metadata but lack full thread content and attachments.

For a complete breakdown of LiveChat extraction methods, see our guide on [How to Export Data from LiveChat](https://clonepartner.com/blog/blog/how-to-export-data-from-livechat-methods-api-limits-formats/).

### Step 2: Download and Re-host Attachments

LiveChat attachments are stored on their CDN, and this is where many migration scripts silently fail.

- **The trap:** URLs exported from LiveChat are temporary or require active authentication. If you skip re-hosting, your migrated records will contain dead links within days.
- **The fix:** Your migration script must download every file from the LiveChat CDN during the extraction phase, store it in an independent storage solution (AWS S3, GCS, or equivalent), and rewrite the URLs in the final payload before loading into Thena. Treat attachment re-hosting as a blocking step, not an afterthought.

### Step 3: Transform the Data

This is where most migrations break. Just as when [migrating from LiveChat to Help Scout](https://clonepartner.com/blog/blog/livechat-to-help-scout-migration-the-technical-guide/), LiveChat's chat → thread → event hierarchy must be **flattened** into Thena's request → comment structure:

- **1 LiveChat chat** = **1 Thena request** (ticket)
- **Each message event within threads** = **1 Thena comment**
- **LiveChat customer** = **Thena requestor** (mapped to an Account)
- **LiveChat tags** → **Thena tags** (direct mapping)
- **LiveChat groups** → **Thena teams** (manual mapping required before extraction begins)
- **LiveChat agent** → **Thena assignee** (agent must pre-exist in Thena; create all agent accounts first)

**Format conversion:** LiveChat uses proprietary HTML-like tags for message formatting. Parse these and convert to plain text or Slack's `mrkdwn` format, depending on where historical data will be rendered in Thena. Unhandled formatting tags render as raw markup noise in the Thena UI.

**Identity resolution:** LiveChat visitors often use different emails across sessions or remain anonymous. Run a lookup against your CRM to match LiveChat customer emails to the Slack workspace domains and company accounts configured in Thena. Customers without email addresses in LiveChat become orphaned records — there is no way to map anonymous browser visitor IDs to authenticated Slack identities. In practice, anonymous visitor records typically represent 15–40% of LiveChat history for B2C-heavy deployments; these will need to be either excluded from migration or stored in a generic "unknown contact" account.

> [!WARNING]
> **Timestamp preservation:** Thena's API does not guarantee that client-supplied `created_at` timestamps are honored for imported records — this behavior depends on your Thena instance configuration and plan tier. Test this against your specific Thena instance with 10–20 sample records before running a full migration. If the server ignores client-supplied timestamps, all migrated records will show the import date. Confirmed workaround: store the original LiveChat `created_at` value in a Thena custom field (e.g., `source_created_at`) so agents retain chronological context.

### Step 4: Load into Thena

Use Thena's Platform API to create requests and comments:

```bash
curl -X POST https://platform.thena.ai/v1/tickets \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "...", "description": "...", "status": "closed", "assignee_id": "..."}'
```

Flag all historical records as `closed` or `archived` before loading to prevent triggering active SLAs, Slack notifications, or webhook automations in your connected systems. Verify this with a small batch (50–100 records) before running the full load.

If Thena is connected to a backend like Zendesk, consider executing the load phase against the Zendesk API and tagging all imported tickets with `source_livechat`. Thena will then surface these records when querying account history through the Zendesk integration.

At 60 requests/min, budget load time at approximately 1.7 hours per 10,000 API calls under ideal conditions, plus retry overhead.

### Step 5: Validate

- **Record count**: Compare total chats extracted vs. requests created in Thena; discrepancies above 2% warrant investigation before going live
- **Message integrity**: Spot-check 5–10% of migrated records for missing comments, truncated messages, or encoding issues
- **Attachment verification**: Confirm files transferred and URLs resolve from the new storage location
- **Customer mapping**: Verify requestor and account associations against your CRM; flag orphaned records for manual review
- **Timestamp audit**: Confirm whether original timestamps were preserved or need to be referenced from custom fields
- **Identity resolution gap**: Quantify the percentage of records with unresolved customer identity; document for agent awareness

## Migration Path: Thena → LiveChat

This direction is less common but occurs when B2B teams pivot to a website-chat-first model — for example, moving into e-commerce or self-serve support (a shift we also see in [Freshservice to LiveChat migrations](https://clonepartner.com/blog/blog/freshservice-to-livechat-migration-the-technical-guide/)).

### Key Differences from the Reverse Migration

- **Thena requests** must map to **LiveChat chats** — but LiveChat chats are real-time conversations, not structured tickets. Imported historical tickets are foreign objects in LiveChat's session-oriented UX.
- **Practical target**: If leaving Thena for the Text ecosystem, the actual import destination is likely **HelpDesk** (Text's ticketing product), not the LiveChat chat system. LiveChat's chat interface has no concept of a ticket-style historical record.
- **Thena export**: Use the dashboard XLSX/JSON export on any plan, or the Platform API on Standard+.
- **Slack thread context loss**: Thena tickets created from Slack messages export the request and comments through the API, but the original Slack thread context — reactions, @mentions, emoji, linked files within the thread — is not captured. The full Slack conversation graph is not reproducible from Thena's export payload.

For more context on Thena-to-other-platform migrations, see our guides on [Thena to Podium](https://clonepartner.com/blog/blog/thena-to-podium-migration-the-ctos-technical-guide/) and [Thena to SurveySparrow](https://clonepartner.com/blog/blog/thena-to-surveysparrow-ticket-management-migration-guide/).

## What Doesn't Migrate (In Either Direction)

| Data/Config | LiveChat → Thena | Thena → LiveChat |
|---|---|---|
| **Automations/workflows** | Must be rebuilt manually | Must be rebuilt manually |
| **SLA policies** | Recreate in Thena's SLA engine | No equivalent in LiveChat |
| **CSAT scores** | No standard import path | No standard import path |
| **Slack thread links** | N/A (LiveChat has no Slack threads) | Lost — LiveChat doesn't map to Slack |
| **Proactive chat triggers** | N/A (Thena doesn't do page-based triggers) | Must be rebuilt as auto-greetings |
| **Knowledge base articles** | Manual recreation | Manual recreation |
| **Analytics/reports** | Historical metrics don't transfer; reconstruct from raw data if needed | Historical metrics don't transfer |
| **Attachments** | Re-upload required (CDN URLs expire) | Re-upload required |
| **Webhook configurations** | Must be reconfigured from scratch | Must be reconfigured from scratch |
| **Slack thread context** | N/A | Lost entirely — not in Thena export payload |

## Edge Cases and Failure Modes

**LiveChat's 60-day history limit on Starter.** Chat history older than 60 days is inaccessible via both the UI and the API on the Starter plan. Upgrade to Team before starting extraction. This is unrecoverable — LiveChat does not offer retroactive history recovery after a plan gap.

**Customer identity mismatch.** This is the primary failure mode. LiveChat identifies customers by email or a browser-generated visitor ID. Thena organizes around company accounts. You need a mapping layer — typically matching LiveChat customer emails to Thena account membership via CRM lookup. Customers without email addresses in LiveChat become orphaned records with no resolution path. Anonymous visitor records typically constitute 15–40% of LiveChat history for B2C-heavy deployments.

**Rate limit collisions.** LiveChat's rate limit is shared across all tokens on a license. If other integrations are running concurrent API calls, your migration script competes for the same 1,000 requests/10-minute window. Run migrations during off-hours or temporarily disable other API consumers.

**Thena API gate at Standard tier.** Starter plan users have zero API access — no programmatic extraction or load is possible. This is a hard licensing gate that must be resolved before any scripted migration work can begin.

**Timestamp backdating uncertainty.** Thena's handling of client-supplied `created_at` timestamps varies by instance configuration. Test with a sample batch before full migration. If timestamps are not honored, store original values in custom fields.

**Thena Slack thread context.** Thena tickets created from Slack messages export only the structured request and comment fields through the API. Slack-native context — reactions, @mentions, threaded sub-conversations, linked files within the thread — is not included in the export payload. This is an architectural limitation of bridging Slack's conversation model to a ticket data model.

**Data retention on lower tiers.** LiveChat Starter: 60-day chat history limit. Thena Free/Starter: retention limits are not explicitly quantified in public documentation. Verify current plan retention policy directly with each vendor before assuming full historical access is available.

## Decision Framework

### Three-Question Decision Tree

**Question 1: Where do your customers contact you?**
- Website → proceed to Question 2 with LiveChat as primary candidate
- Slack Connect or MS Teams → Thena; stop here unless you also need a website widget
- Both channels → read the hybrid scenario above; no single platform covers both cleanly

**Question 2: What is your customer model?**
- Anonymous visitors, high volume, short sessions → LiveChat
- Named accounts, multi-user companies, ongoing relationships → Thena
- Mixed (B2B SaaS with self-serve and enterprise tiers) → evaluate ticket volume per channel before deciding; the channel with >60% of volume should determine platform choice

**Question 3: Do you need AI natively bundled?**
- Yes, and you want it integrated with routing and account context → Thena (AI agent studio is included from Standard tier; MCP — Model Context Protocol — server allows Thena to connect AI agents to external tools and data sources natively)
- Yes, but you can manage a separate product and billing relationship → LiveChat + ChatBot ($52+/mo additional)
- No → cost comparison alone should drive the decision

**If all three answers point to the same platform:** straightforward choice. If they split — for example, website-facing with named accounts — you are in hybrid territory. Run both platforms for 60–90 days with clean analytics separation, then consolidate to whichever channel generates more resolvable tickets.

## Making the Migration Work

Migrating between LiveChat and Thena is a data model translation problem, not a file copy. The platforms have fundamentally different architectures, different API designs, and different definitions of what a "conversation" is.

Getting it right requires:
1. Understanding both data models at the field level before writing any extraction code
2. Handling rate limits programmatically with proactive throttling, not reactive 429 handling
3. Re-hosting attachments before CDN authentication windows expire
4. Running CRM-based identity resolution to handle anonymous visitors and multi-email customers
5. Testing timestamp behavior on a sample batch before committing to a full migration
6. Accepting that automations, SLA configurations, webhook setups, and analytics must be rebuilt from scratch — these do not transfer in either direction

To mitigate risk, always run a delta migration: extract and map your data, validate identity resolution in a sandbox environment against a representative 500–1,000 record sample, and only cut over live routing once the historical archive is fully accessible and spot-checked by your agents.

> Need to migrate between LiveChat and Thena without losing your historical data? ClonePartner's engineering team handles the data model translation, API scripting, and validation — so you don't have to. Book a 30-minute call to scope your migration.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)

## Frequently asked questions

### Is there a native migration tool between LiveChat and Thena?

No. Neither platform offers a built-in import/export tool for the other, and no third-party migration tool currently offers a verified connector. Migration requires extracting data via LiveChat's Agent Chat API v3.5, transforming it to match Thena's request/comment schema, and loading it through Thena's Platform API (Standard plan or above required for API access).

### Can I migrate LiveChat history directly into Slack channels using Thena?

No. Slack's API does not allow external applications to backdate messages or impersonate users. Historical LiveChat data must be migrated to Thena's web dashboard or your underlying CRM/ticketing system (such as Zendesk) as archived requests.

### What data is lost when migrating from LiveChat to Thena?

Automations, SLA policies, CSAT scores, proactive chat triggers, knowledge base articles, and historical analytics do not transfer. Attachments require re-upload since LiveChat CDN URLs expire. Original timestamps may not be preservable via Thena's API — verify before migration and use custom fields as a workaround.

### How much does LiveChat cost compared to Thena in 2026?

LiveChat ranges from $20–$59/agent/month (annual billing), with ChatBot as a separate $52+/month add-on. Thena offers a free tier (10 users, 1,000 tickets/month), then $29–$119/user/month on paid plans with AI included. A 10-agent team on LiveChat Business with ChatBot costs ~$642/month; the same team on Thena Standard costs ~$790/month.

### Can I use Thena's API on the Starter plan?

No. Thena gates API access to the Standard plan ($79/user/month) and above. Starter plan users can only export data manually via the dashboard in XLSX or JSON format. This affects both migrations and custom integrations.