---
title: "Migrate to Gorgias: Helpdesk Migration Guide & Service"
description: "Migrating to Gorgias? Import limits, the full migration checklist and every source FlitStack AI moves into Gorgias, with history and rollback."
url: "https://flitstack.ai/migrations/helpdesk/gorgias"
---

# Migrate to Gorgias

Gorgias is an e-commerce-native helpdesk built around Shopify, BigCommerce and Magento, whose migration model rewards teams that pre-map Tickets and Customers, rebuild Rules and Macros from documentation, and budget for the 720-tickets-per-hour native importer.

Short answer

FlitStack AI migrates tickets, threads, and customer histories into Gorgias from 250+ helpdesks. Every field is mapped to Gorgias's objects, history and associations come across, the Gorgias setup is configured alongside, and the whole migration stays reversible in one click.

![](https://flitstack.ai/images/authors/aditya-kumar.webp)By [Aditya Kumar](https://flitstack.ai/about/aditya-kumar) Updated November 5, 2026

[Get a quote ](https://flitstack.ai/contact) [See every source →](https://flitstack.ai/migrations/helpdesk/gorgias#sources-list)

![](https://flitstack.ai/images/illustrations/pair-stage.webp)

From Your system

Destination Gorgias ![](https://flitstack.ai/platforms-trim/gorgias.webp)

250+ sources mapped into Gorgias

## What Gorgias supports, and where its import tools stop

- Shopify-native integrations pull order details, shipment status, and return data directly into the ticket view, eliminating the need for agents to switch between apps.
- Unlimited user seats mean growing support teams do not trigger billing changes; pricing scales only on billable ticket volume.
- AI Agent automates responses to high-volume queries like order status and returns, measurably reducing the number of billable tickets each month.
- Omnichannel inbox consolidates email, live chat, Facebook, Instagram, WhatsApp, SMS, and voice into a single threaded view.

**Bulk API** OAuth 2.0 or API key

**Rate limits** 40 req/20s (API key) or 80 req/20s (OAuth2); Enterprise uses 10-second window

| Object                    | Support | Note                                                                                                                                                                                                                                                                                                                                               |
| ------------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tickets                   | full    | Tickets are the primary billing and workflow unit in Gorgias. Standard fields (priority, status, assignee, timestamps, channel) are stable and well-documented in the API. We migrate Tickets with all meta fields intact and flag which records were created via AI Agent so the destination system can reflect resolution attribution correctly. |
| Customers                 | full    | Customers represent the end shoppers and are linked to ticket history. The API supports create, update, delete, and merge operations. We preserve the customer-to-ticket linkage and handle the merge operation by de-duplicating matched records and keeping a reference to the merged master ID.                                                 |
| Agents                    | full    | Agents are the support staff users. We migrate agent profiles including name, status, and group membership. Dynamic action fields on agents require mapping to the destination system's permission model or custom fields.                                                                                                                         |
| Groups                    | full    | Groups (also called Teams) organize agents for routing and assignment. We preserve group membership and map it to the equivalent team or queue concept in the destination platform.                                                                                                                                                                |
| Macros                    | full    | Macros are saved reply templates with variable substitution and dynamic action fields. We export the full macro body, conditions, and action sequence. Destination platforms without a native macro concept receive them as templated draft messages or saved-snippet records.                                                                     |
| Rules                     | full    | Rules define ticket routing, assignment, and auto-responses. We map rule conditions and actions to equivalent workflow or automation constructs in the destination platform, noting which rules were triggered by AI Agent versus manual configuration.                                                                                            |
| Views                     | mapped  | Views are saved filter configurations that organize the ticket queue. We export the filter logic (field conditions, operators, sort order) and recreate them as saved views or saved searches in the destination system, though the UI representation may differ.                                                                                  |
| Custom Fields             | mapped  | Custom fields exist on both Tickets and Customers and support string, boolean, date, number, select, and multi-select types. We preserve field type and archived status. Select and multi-select fields require value mapping if the destination uses a different picklist schema.                                                                 |
| Knowledge Base Categories | full    | Top-level KB categories with name, position, and translations. We migrate category hierarchy and ordering, and preserve translation content for each enabled locale.                                                                                                                                                                               |
| Knowledge Base Articles   | full    | KB articles contain title, body (HTML), author, folder assignment, status, and translations. We preserve full article body content, author attribution, and locale-specific translations. Articles in draft status are flagged for review after migration.                                                                                         |
| Conversations             | full    | Conversations are the individual messages within a ticket, including internal notes and public replies. We migrate the full message history with author, timestamp, privacy flag, and attachments. Attachments are fetched by URL and re-uploaded to the destination system's storage.                                                             |
| Attachments               | mapped  | File attachments on tickets and comments are stored externally and referenced by URL. We download attachments during migration and re-upload to the destination, handling file type restrictions and size limits on the target platform.                                                                                                           |
| Satisfaction Surveys      | full    | CSAT ratings submitted via Gorgias's built-in satisfaction survey are associated with tickets. We migrate the rating score, free-text response, and timestamp, preserving the linkage to the originating ticket.                                                                                                                                   |
| Tags                      | mapped  | Tags are applied to tickets and customers for categorization. We migrate tags as-is and map them to the destination platform's tagging scheme, flagging any tag names that conflict with reserved system labels.                                                                                                                                   |
| Settings                  | mapped  | Account-level settings include channel configurations, SLA rules, and notification preferences. These are migrated as configuration records that must be reviewed and applied manually post-import, since many depend on destination-specific feature availability.                                                                                |

## The Gorgias migration guide

## Why teams migrate to Gorgias

*The four shapes a Gorgias migration takes, and what makes the platform easier — or harder — than the category average.*

Gorgias was founded in 2015 by Romain Lapeyre and Alex Plugaru and is headquartered in San Francisco, with engineering in Paris. It is an e-commerce-native helpdesk built around deep Shopify, BigCommerce and Magento integration, and reached an estimated $69M ARR in 2024 serving over 15,000 online merchants including Steve Madden, Glossier and BruMate.

The typical Gorgias customer is a direct-to-consumer brand running on Shopify with 2 to 50 support agents and a ticket volume that scales with seasonal commerce. Compared with Zendesk, Gorgias positions on faster setup and a tighter e-commerce data model — refunds, edits and cancellations happen inside the ticket without a tab-switch[9](https://flitstack.ai/migrations/helpdesk/gorgias#source-9). Compared with Help Scout or Front, it positions on the depth of the Shopify product-catalogue and order-context integration.

The shapes of migration that actually land on Gorgias tend to fall into four patterns. First, Zendesk exits by Shopify-first merchants who want the order-context overlay; Gorgias ships a native Zendesk importer specifically for this shape[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). Second, consolidation projects: a brand replacing Gmail-plus-Facebook-Messenger-plus-Aircall with one inbox.

Third, legacy replacements from Freshdesk, Help Scout, Intercom or Re:amaze, where the source schema is parallel but Rules and Macros do not map across. Fourth, growth-stage upgrades where a brand that started on a shared Gmail account hits 100+ daily tickets and needs ticket routing, SLAs and CSAT.

Each shape has a different difficulty profile: a Zendesk migration has clean object parity but two-year and 250-comment caps in the native tool[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12), while a homegrown-Gmail migration has no schema to map but every Macro and Rule has to be rebuilt by hand.

What makes migrating to Gorgias easier than the category average is the native Zendesk importer plus the partner-built Help Desk Migration (HDM) app, which covers 80+ source helpdesks and runs from inside Gorgias under Settings → App Store[3](https://flitstack.ai/migrations/helpdesk/gorgias#source-3).

What makes it harder than the average is the ticket-based pricing model, which bills per billable ticket on the Starter and Basic plans and can punish teams that import two years of historical tickets without thinking through which ones become billable. Rules, Macros, AutoResponders, Flows and Help Center theme customisations do not import — they are rebuilt from documentation.

Teams that scope for that rebuild work up front finish on time; teams that assume the importer carries automations across do not.

> Teams that scope for the automation rebuild up front finish on time; teams that assume the importer carries Rules and Macros across do not.

## The Gorgias data model you need to map into

*Tickets, Messages, Customers, Users, Views, Macros — the destination schema decoded, with the upsert keys you'll wire on every field.*

Gorgias is built around a small set of resources. The two load-bearing objects are Ticket and Customer, with Messages nested as an array inside each Ticket. Everything else — Views, Macros, Rules, Tags, Custom Fields, Voice Calls — orbits around those two[16](https://flitstack.ai/migrations/helpdesk/gorgias#source-16).

Before you map a field on the source side, you need to know exactly which destination resource the row belongs on, what the create flow requires, and which value will serve as the upsert key. The table below summarises the objects you will touch in a Gorgias migration.

| Object                   | What it stores                                                      | Required                                                             | Tier                                        |
| ------------------------ | ------------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------- |
| Tickets                  | A single customer issue with a thread of messages                   | Customer reference (id or email), channel, at least one message      | All plans                                   |
| Messages (TicketMessage) | Individual replies, notes, or system events inside a ticket         | body\_text or body\_html, sender, channel; max 1 MB per message body | All plans                                   |
| Customers                | End-user contact records — name, channels, addresses, custom fields | At least one channel (email, phone, social handle)                   | All plans                                   |
| Users (Agents)           | Internal team members who handle tickets                            | Email, name, role                                                    | All plans; seat counts gated by plan        |
| Tags                     | String labels applied to tickets for grouping and Rule conditions   | Name (case-sensitive on import)                                      | All plans                                   |
| Custom Fields            | Per-Ticket or per-Customer typed metadata                           | object\_type (Ticket or Customer), label, definition                 | All plans                                   |
| Macros                   | Pre-written reply templates with variables and actions              | name, body\_text, tags                                               | All plans; advanced actions on higher tiers |
| Rules                    | Trigger-based automation: when X, then Y on ticket lifecycle        | Condition tree, action list — rebuilt manually, not imported         | All plans; rule count gated by plan         |
| Views                    | Saved filter queries over tickets (Unassigned, Urgent, etc.)        | Name, filter definition                                              | All plans                                   |
| Help Center Articles     | Knowledge base articles, categories, translations                   | Title, body, category, status                                        | Basic plan and above                        |
| Voice Calls              | Call records linked to tickets (Aircall integration)                | Linked Ticket id, direction, timestamp                               | Plans with Voice add-on                     |
| Integrations / Widgets   | Custom HTTP integrations and right-sidebar widgets                  | Rebuilt manually in Settings → Integrations                          | All plans                                   |

Customers use email (or another channel address — phone, Facebook ID, Instagram handle) as the de-facto unique identifier. Two tickets that arrive from the same email collapse onto the same Customer record automatically. The Customer object also supports an external\_id field for round-tripping the source platform's primary key, which is the cleanest upsert pattern when you control the loader[4](https://flitstack.ai/migrations/helpdesk/gorgias#source-4).

Tickets do not have a natural unique key beyond Gorgias's own auto-assigned `id`. The recommended pattern is to capture the source platform's ticket id in a Custom Field of type `text` on the Ticket object (with `object_type=Ticket`) and use it for reconciliation[4](https://flitstack.ai/migrations/helpdesk/gorgias#source-4). Custom Fields exist for two `object_type` values only — Ticket and Customer — and the supported `definition` data types are boolean, number, and text[4](https://flitstack.ai/migrations/helpdesk/gorgias#source-4).

| Field type                   | Limit                                            | Notes                                                                                                                                                          |
| ---------------------------- | ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| text                         | 1 to 1024 chars (label); body varies             | Free-form string; the workhorse type for source id round-trip                                                                                                  |
| number                       | Signed numeric                                   | No formula type — calculations rebuilt outside Gorgias                                                                                                         |
| boolean                      | true / false                                     | Defaults configurable per field                                                                                                                                |
| Single-select / Multi-select | Defined in `definition` payload                  | Picklist values stored as strings — case-sensitive on Rule match                                                                                               |
| Required flag                | boolean per field                                | Defaults to false; required fields block ticket close in some UI flows                                                                                         |
| Custom field priority        | 0 to 5000                                        | Controls display order on ticket and customer sidebar[4](https://flitstack.ai/migrations/helpdesk/gorgias#source-4)                                            |
| Macro body                   | CSV import: UTF-8 only, formatting not preserved | Macro import supports 4 columns: name, body\_text, tags, id[6](https://flitstack.ai/migrations/helpdesk/gorgias#source-6)                                      |
| Ticket message body          | 1 MB per `body_text` or `body_html`              | Bodies over 1 MB return HTTP 400 on create/update; pre-existing oversized messages are truncated[7](https://flitstack.ai/migrations/helpdesk/gorgias#source-7) |

Relationships in Gorgias are flat compared with a CRM. A Customer has many Tickets; a Ticket has many Messages and many Tags; a Macro can reference variables that pull from the Customer or Ticket context. There is no master-detail cascade — deleting a Customer does not delete their Tickets; the tickets are reassigned to a placeholder customer. There is no junction object pattern — tag many-to-many is handled internally[16](https://flitstack.ai/migrations/helpdesk/gorgias#source-16).

Help Center articles are a separate top-level resource organised as top-level categories → categories → articles, with optional translations per article. They are not tickets and do not share the customer relationship; they are migrated through their own import path described in Section 4 and their own field set.

## Pre-migration prep — the work before you touch Gorgias

*What must be true on the source, the destination, and across the team before the first ticket lands in the new helpdesk.*

The single best predictor of a clean Gorgias migration is how much work you do on the source side before the first import starts. Practitioners migrating from Zendesk consistently report that the import itself is reliable; what burns time is the post-import realisation that Rules, Macros and SLA policies were not in scope and need to be rebuilt under deadline.

> The single best predictor of a clean migration is how much work you do before the first ticket lands in the new helpdesk.

Treat the source export as raw material that needs to be shaped to Gorgias's expected formats — email lowercased, phone normalised to E.164, tags converted to the casing they will live under in Gorgias Rules, message bodies sanity-checked against the 1 MB limit, attachments inventoried for re-upload[7](https://flitstack.ai/migrations/helpdesk/gorgias#source-7).

### Source-side prep

- Audit and dedup Customer records before export. Gorgias collapses tickets onto a Customer record by email (or phone/social handle); duplicate customers in the source produce orphaned ticket histories spread across two Customer records that have to be merged via the merge function after import.
- Normalise emails to lowercase and trim whitespace; strip role-based addresses (info@, sales@) that you do not want generating billable tickets in Gorgias.
- Inventory Macros, Rules and AutoResponders from the source platform. Export each one to a tracked document — these do not move and you will rebuild them from this spreadsheet during Section 5.
- Stamp a stable external id on every Ticket and Customer in the source export — the source platform's primary key — so re-runs and reconciliation are deterministic. This lands in a `text` Custom Field on the Gorgias side[4](https://flitstack.ai/migrations/helpdesk/gorgias#source-4).
- Decide the historical scope. The native Zendesk importer caps at the last two years of data and splits any ticket with more than 250 comments into multiple closed tickets[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). Help Desk Migration's third-party tool has no hard time cap but bills per record[3](https://flitstack.ai/migrations/helpdesk/gorgias#source-3). Either path requires a deliberate decision before scope is signed.

### Destination-side prep

- Provision a sandbox account via the Gorgias Partner Portal (partners.gorgias.com). New sandbox accounts default to Demo; email support\@gorgias.com with the account URL to convert to the partner plan for full-fidelity testing[15](https://flitstack.ai/migrations/helpdesk/gorgias#source-15).
- Provision Users (agents) first with the correct roles — Admin, Agent, Lite — under Settings → Team. Only Admins can run imports, and only the Account Owner can transfer ownership[22](https://flitstack.ai/migrations/helpdesk/gorgias#source-22). Owner-on-ticket assignment during import fails silently if the referenced agent does not exist.
- Pre-create every Custom Field on the right object (Ticket or Customer) with the right data type before importing. Custom Fields with the wrong `object_type` cannot be reused[4](https://flitstack.ai/migrations/helpdesk/gorgias#source-4).
- Connect channels — email (direct integration or auto-forwarding), Shopify/BigCommerce/Magento, chat, Facebook, Instagram, WhatsApp, SMS, Aircall — before importing historical tickets, but with the source platform's matching channel disconnected so messages do not arrive twice[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12).
- Pre-create top-level categories and categories in the Help Center before importing articles via CSV. Articles target an existing category by name and fail if the category is missing.

### People prep

Cutover only works if humans cooperate. Lock down a source-system freeze window — typically 24 to 72 hours for a small DTC brand, longer for a multi-channel brand with social and voice — and communicate it to every department that touches the helpdesk. Train agents on Gorgias daily workflows, Macros, Views and the Customer sidebar (with Shopify order context) before go-live, not after.

A typical small-merchant migration runs one to three business days of elapsed time; a multi-channel brand with two years of Zendesk history runs five to fourteen days because the native importer processes around 720 tickets per hour and a 250,000-ticket history therefore takes roughly two weeks[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). Build the runway accordingly.

## Import mechanisms: native importer and CSV paths

*Two main paths in, each with different limits and shapes. Picking the wrong one is how a Gorgias migration stalls at 720 tickets per hour.*

Gorgias exposes load paths whose right choice depends on the source platform and dataset size. The native Zendesk Import covers the single most common source. The Help Desk Migration (HDM) partner app, accessible from inside Gorgias, covers 80+ other source helpdesks.

### Native Zendesk Import

The Zendesk importer lives at Settings → Import data → Add account. It pulls tickets, macros, users, tags and ticket fields from Zendesk into Gorgias and, after the initial import, runs a continuous sync from the cut-off point forward[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). Setup needs the Zendesk subdomain and Zendesk Admin credentials, and only Gorgias Admins can run it.

Limits to plan around: up to two years of the most recent ticket data, tickets with more than 250 comments are split into multiple closed tickets, deleted or blank Zendesk tickets are skipped, ticket statuses sync as open or closed only (no pending/on-hold equivalent), and the throughput averages 720 tickets per hour[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12).

The continuous sync ingests in three phases — last two weeks, then 730 days back to 2 weeks ago oldest-first, then forward — and the same email channel must not be enabled on both platforms during the import or messages duplicate[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12).

### Help Desk Migration (HDM) partner app

Built by Relokia and accessed inside Gorgias at Settings → App Store → All Apps → Help Desk Migration[3](https://flitstack.ai/migrations/helpdesk/gorgias#source-3). It supports 80+ source helpdesks including Freshdesk, Help Scout, Intercom, Kustomer, Re:amaze, Zoho Desk and Front. It runs a free Demo Migration on 20 tickets plus 20 articles so you can validate the mapping before committing, then a paid full migration that handles Delta migration, Interval, and re-migration while preserving relationships[3](https://flitstack.ai/migrations/helpdesk/gorgias#source-3).

HDM covers Tickets and their comments (with privacy and publicity flags), Customer profiles, Agents, Groups, Tags, Custom Fields (text/boolean/dates/number/select/multi-select), Macros, and Help Center top-level categories, categories and articles including translations. Inline images and call recordings move as ticket attachments. Pricing is per-record and depends on dataset size and selected options[3](https://flitstack.ai/migrations/helpdesk/gorgias#source-3).

### CSV imports

Two narrow CSV import paths exist inside the UI: Macro CSV import under Settings → Productivity → Macros (4 columns: name, body\_text, tags, id, UTF-8 encoded)[6](https://flitstack.ai/migrations/helpdesk/gorgias#source-6), and Help Center article CSV import for knowledge-base content. Attachments must be uploaded separately and then referenced when creating the Ticket Message that owns them[21](https://flitstack.ai/migrations/helpdesk/gorgias#source-21).

Migrating from Zendesk → native Zendesk Importer. Migrating from any other helpdesk → Help Desk Migration app (Settings → App Store).

## Mapping your data into Gorgias

*The longest section — because helpdesk mapping is where Tickets, Messages, Macros, Rules and SLA history all earn their scars.*

Mapping is where every helpdesk migration earns its scars. The schema decisions you make in your mapping spreadsheet determine whether Rules fire correctly on day two, whether SLA reports work on day five, and whether your support team trusts the Customer sidebar on day thirty.

Work resource by resource, in this load order: Users (agents) first so ticket owner references resolve, then Tags so ticket tag references resolve, then Customers so ticket customer references resolve, then Custom Fields, then Tickets-with-Messages, then Macros, then Help Center articles. Rules, AutoResponders and SLA policies are rebuilt in the UI after data lands.

### Customers

| Source                         | Destination                                           | Note                                                                                                              |
| ------------------------------ | ----------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| email                          | channels\[type=email].address                         | Lowercased on import; primary upsert match key for inbound tickets                                                |
| first\_name / last\_name       | firstname / lastname                                  | Combined into `name` if `name` is missing on payload                                                              |
| phone                          | channels\[type=phone].address                         | Normalise to E.164 before import                                                                                  |
| social handle (FB/IG/WhatsApp) | channels\[type=facebook\|instagram\|whatsapp].address | Multi-channel customers consolidate onto one record                                                               |
| source platform id             | external\_id                                          | First-class field for round-trip and reconciliation[4](https://flitstack.ai/migrations/helpdesk/gorgias#source-4) |
| shopify customer id            | Set via Shopify integration enrichment post-import    | The Shopify integration matches by email at runtime                                                               |
| custom contact fields          | Custom Fields with object\_type=Customer              | Pre-create on the Customer object before import[4](https://flitstack.ai/migrations/helpdesk/gorgias#source-4)     |

### Ticket history with Messages array (public + internal\_note flag)

A Ticket in Gorgias is a header (subject, channel, status, assignee, tags) plus an ordered array of Messages. Each Message has a `body_text` and/or `body_html` (capped at 1 MB per body[7](https://flitstack.ai/migrations/helpdesk/gorgias#source-7)), a `sender` reference (a Customer or a User), a `channel` value matching the ticket's channel, and a critical `public` flag — `public: true` means the message is visible to the customer, `public: false` means it is an internal note.

When mapping from a source platform whose comments have a `private`/`public` flag (Zendesk's `public`, Freshdesk's `private`, Help Scout's `customer_id` presence), preserve the polarity carefully — flipping it converts internal triage discussion into customer-visible replies, which is the single most-cited Gorgias migration regret on Reddit and in vendor changelogs.

| Source                            | Destination                                                                                              | Note                                                                                                                              |
| --------------------------------- | -------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| ticket id (source)                | Custom Field on Ticket (text)                                                                            | Use for reconciliation and cross-system links; Gorgias assigns its own id                                                         |
| subject                           | subject                                                                                                  | Max 998 chars; longer subjects truncated[19](https://flitstack.ai/migrations/helpdesk/gorgias#source-19)                          |
| status (open/pending/solved)      | status (open/closed)                                                                                     | Gorgias has open or closed only; pending/on-hold collapse to open[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12) |
| channel (email/chat/voice/social) | channel                                                                                                  | Map to email, chat, facebook, instagram, whatsapp, sms, phone, contact-form                                                       |
| assignee\_id                      | assignee\_user.id                                                                                        | Resolve agent email/id against pre-provisioned Users                                                                              |
| tags\[]                           | tags\[]                                                                                                  | Case-sensitive — tags used in Rule conditions must match exactly                                                                  |
| created\_at                       | created\_datetime                                                                                        | ISO-8601; Gorgias preserves on import via the HDM tool                                                                            |
| comments\[].body                  | messages\[].body\_html or body\_text                                                                     | Max 1 MB per message[7](https://flitstack.ai/migrations/helpdesk/gorgias#source-7); longer messages return HTTP 400               |
| comments\[].private               | messages\[].public (inverted)                                                                            | private:true → public:false (internal note); preserve polarity                                                                    |
| comments\[].author\_id            | messages\[].sender                                                                                       | Customer reference for customer messages, User reference for agent                                                                |
| attachments\[]                    | Upload separately then attach to message[21](https://flitstack.ai/migrations/helpdesk/gorgias#source-21) | Multi-step: upload returns file id, then create message referencing it                                                            |

### Help Center article import

Help Center content is migrated either via the HDM partner app — which preserves articles, categories, translations and inline media as attachments — or via the native Help Center CSV import path. The CSV import handles Top-level categories → Categories → Articles with fields title, body, author, folder, status, and translations.

Images, GIFs and other inline media are not preserved through the CSV path — they are re-uploaded after the article body is loaded, and most practitioners use this as the cue to audit and refresh visual assets.

### Macros, Rules and AutoResponders — rebuild, not migrate

Macros have a narrow CSV import (4 columns: name, body\_text, tags, id; UTF-8 encoded; formatting not preserved)[6](https://flitstack.ai/migrations/helpdesk/gorgias#source-6). Tags referenced in the macro must exist before the import or the row is skipped. If an `id` matches an existing Macro the import updates it; if no `id` is provided a new Macro is created[6](https://flitstack.ai/migrations/helpdesk/gorgias#source-6).

Rules and AutoResponders do not import. They are rebuilt manually in Settings → Automation → Rules and Settings → Automation → AutoResponders. Export every Rule from the source platform to a tracked spreadsheet — trigger, conditions, actions — and rebuild each one in the Gorgias UI. The Rules engine in Gorgias is condition-tree-based with actions covering tag assignment, ticket assignment, macro application, status change and HTTP integration calls. Flows (chat conversation logic) and Order Management (Shopify-aware automation) are similarly rebuilt under Settings → Automation.

### SLA and CSAT history

Gorgias supports per-channel SLA policies under Settings → Productivity → SLAs that fire when a ticket meets condition criteria (priority, tag, channel). SLA configuration does not migrate — define each policy fresh in the UI. Historical SLA attainment from the source platform also does not migrate; the cleanest pattern is to export the source's last-quarter SLA report as a PDF and archive it, then start the SLA clock fresh in Gorgias from import day.

CSAT history is similar. Gorgias's native satisfaction survey and CSAT score are computed from the date you enable the survey forward; pre-import CSAT scores from Delighted, Trustpilot or the source helpdesk are not back-populated. Run the Delighted Gorgias integration via HTTP Integration (Settings → Integrations → HTTP, trigger on Ticket updated) to survey-send going forward; if you need the historical CSAT report preserved, archive it as a PDF.

### Multi-channel inbox: email, chat, social, SMS, voice

Gorgias's multi-channel inbox is set up per channel and per integration after the historical import has finished, with the source-platform side of each channel disabled in lockstep[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). The supported channels are email (direct Gmail/Outlook integration or forwarding), Help Center contact form, native Chat widget, Facebook Messenger, Instagram (DMs and comments), WhatsApp Business, SMS, and phone via Aircall.

The single most common channel-migration mistake is leaving the source platform's email integration enabled while Gorgias is also pulling that mailbox: every inbound email creates two tickets, one on each platform, and the continuous-sync layer duplicates the message back into the original ticket[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). The sequence is: complete the Zendesk import → enable the new email channel in Gorgias → pause the Zendesk sync → disable the email channel on the Zendesk side → repeat per channel.

### Shopify / BigCommerce / Magento customer + order context

The e-commerce integration is what makes Gorgias Gorgias. The Shopify integration is installed via Settings → Integrations → Shopify, connects to one or many Shopify stores, and at runtime pulls the customer's full order history, line items, fulfilment status and customer-lifetime-value onto the right-hand sidebar of every ticket. BigCommerce and Magento integrations follow the same pattern.

Order context is not migrated as data — it is queried live from Shopify on every ticket open via the integration. The implication for migration: the matching is by Customer email, so the customer-email normalisation work from Section 3 is what makes the Shopify sidebar populate correctly on day two. Tickets that ended up with the wrong email after import will show no Shopify context until the email is fixed.

### Files, attachments and call recordings

Attachments require a multi-step process: the file is uploaded first, returns an id, and is then referenced when creating the Ticket Message that owns the attachment[21](https://flitstack.ai/migrations/helpdesk/gorgias#source-21). HDM and the native Zendesk importer handle this multi-step pattern automatically; inline images embedded in article HTML need to be re-uploaded separately.

Call recordings from Aircall or Zendesk Voice are imported as ticket attachments by HDM rather than as native Voice Calls — historical voice analytics are therefore preserved as audio but not as searchable transcripts.

### Audit trail, ownership and original timestamps

Ticket `created_datetime` and message timestamps are preserved on import when you go through the native Zendesk Importer or HDM[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). The Gorgias audit log, accessible under Settings → Audit logs, captures events from import-day forward and retains them for up to 12 months as of the February 25, 2026 retention change[19](https://flitstack.ai/migrations/helpdesk/gorgias#source-19) [20](https://flitstack.ai/migrations/helpdesk/gorgias#source-20). Pre-import audit history from the source platform is not migrated; export it before cutover if you need to retain it for compliance.

Ticket ownership (assignee) maps to a Gorgias User and resolves at import time against the email of the source-platform agent. Agents whose email does not match a provisioned Gorgias User end up with their tickets unassigned, which silently breaks downstream owner-based Rules. Match emails before the import or remap unassigned tickets in bulk after.

## The pitfalls that derail Gorgias migrations

*Nine specific failure modes — ranked by impact, each tied to the exact Gorgias mechanism that breaks.*

**high Billable-ticket overage on Starter and Basic plans after historical import**

Gorgias's Starter and Basic plans bill per billable ticket — the included quota is set by plan tier and overage is charged per additional ticket. Importing two years of Zendesk history into a Starter or Basic plan account counts each historical ticket against the current month's quota and triggers an overage on the next invoice that can be five or ten times the base plan price. Migrate onto Pro or Advanced if your imported volume exceeds the Basic quota, or import in batches across billing cycles with quota monitored each week.

**high Same email channel enabled on both platforms during cutover**

If the Zendesk Gmail integration and the Gorgias Gmail integration are both connected to the same mailbox during the import window, every inbound email creates two tickets — one in each helpdesk — and the continuous Zendesk-to-Gorgias sync duplicates the message back into the Gorgias-side ticket[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). The fix is the documented sequence: complete the import, enable the Gorgias channel, pause the Zendesk sync, then disable the Zendesk channel — one channel at a time, never overlapping.

**high 250-comment cap splits long tickets into multiple closed tickets**

The native Zendesk importer splits any ticket with more than 250 comments into multiple closed tickets in Gorgias[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). Long-running VIP support threads — onboarding tickets, complex escalations, account-management conversations that have lived for months — therefore arrive as a chain of separate, closed tickets with no native link between them. Identify these in the source export before the import and stamp them all with the same Custom Field value so Views can reassemble them.

**high Internal note vs public message polarity flip on import**

Gorgias Messages use a `public` boolean — `public: true` is customer-visible, `public: false` is an internal note. Source platforms model the same concept with inverted polarity: Zendesk's `public`, Freshdesk's `private`, Help Scout's missing `customer_id`. A loader that copies the source flag verbatim without checking semantics turns every internal triage discussion into a customer-visible reply. Validate on a 50-ticket sample before scaling — a single mistake here generates customer-facing apology emails for weeks.

**high 1 MB ticket message body cap rejects large messages**

Since January 31, 2023, ticket message `body_text` and `body_html` are limited to 1 MB each; create and update flows reject a body that exceeds this, and pre-existing oversized messages are truncated to fit[7](https://flitstack.ai/migrations/helpdesk/gorgias#source-7). The error message does not identify which field is over the limit. Large customer emails with quoted history (forwarded threads, bug reports with stack traces) routinely cross 1 MB. Pre-process source bodies to detect and either truncate-with-marker or split into multiple Messages before the load.

**medium Macro CSV import skips lines silently if tags do not exist**

The Macro CSV import path supports 4 columns — name, body\_text, tags, id — and requires UTF-8 encoding with no capitalisation in the column names[6](https://flitstack.ai/migrations/helpdesk/gorgias#source-6). Macros referencing tags that do not already exist in the account are skipped silently with no row-level error; formatting in the body is not preserved on import. Pre-create every tag referenced by any macro before the CSV import, and validate the macro count after import against the source export. The same pattern applies to Help Center article CSV import — categories must exist first.

**medium Audit log retention capped at 12 months from February 2026**

Effective February 25, 2026, Gorgias audit log events are retained for a maximum of 12 months and events older than that are permanently deleted from the system[20](https://flitstack.ai/migrations/helpdesk/gorgias#source-20). If your compliance or SOC 2 evidence requires longer retention, export audit log events on a rolling schedule and archive them in your own storage — Gorgias will not retain them for you. SOC 2 Type II certified accounts also need to factor this into their evidence collection cadence[17](https://flitstack.ai/migrations/helpdesk/gorgias#source-17).

**low Status collapse: pending and on-hold both arrive as open**

Gorgias models ticket lifecycle as open or closed only; source platforms with richer status models (Zendesk's pending, on-hold, solved-vs-closed; Freshdesk's pending and waiting on customer) collapse onto Gorgias's binary[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). Reports filtered by 'pending' on the source side do not have a direct Gorgias equivalent. The mitigation is to model the missing statuses as tags on the Gorgias side — `pending`, `on-hold` — apply them during import, and rebuild status-filtered Views with tag conditions instead of native status conditions.

## Validation and cutover

*What to verify after the import job, in what order — and how to fail safely when something is wrong.*

Validation is the bridge between the import finishing and your agents being allowed in. The most reliable signal is having team leads from each support channel verify the tickets they personally remember — they know what right looks like in a way no reconciliation script can match.

Build a reconciliation queries spreadsheet that compares source and destination on each of these counts. Anything outside a 0.5 percent variance gets investigated before agents get login access.

- Total tickets imported vs source — minus the deliberately excluded buckets (deleted Zendesk tickets, blank tickets, tickets outside the two-year window)[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12).
- Tickets per channel (email, chat, Facebook, Instagram, WhatsApp, SMS, phone, contact-form) — confirm the channel distribution roughly matches the source.
- Tickets per status (open, closed) and per tag — and confirm the pending/on-hold-equivalent tags are populated where the source had richer statuses.
- Messages per ticket — sum and compare; particular attention to the 250-comment-cap tickets that arrive as split chains[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12).
- Public-vs-internal message ratio — a sample of 50 tickets verified by hand catches polarity flips on the `public` boolean before they reach customers.
- Customers imported vs source — and a count of how many resolve to a Shopify customer via email matching once the Shopify integration is wired.
- Tags created vs source — case-sensitivity matters because Rules will fire only on exact matches.
- Macros imported vs source — and confirm the body formatting was acceptable for the templates that rely on visual structure[6](https://flitstack.ai/migrations/helpdesk/gorgias#source-6).
- Help Center articles, categories and translations — and a manual check that inline media re-uploaded where the CSV path dropped it.
- Agent assignment — `GROUP BY assignee_user` and confirm no agent's queue is suspiciously empty (a sign of unresolved email mapping).

On top of reconciliation, run a manual spot-check protocol: pick 30 random tickets across channels and verify each one against the source UI — subject, status, all messages, internal-vs-public flag on each, attachments, tags, assignee. Pick five high-value VIP tickets and trace the full thread. If a non-trivial discrepancy shows up in three or more of the 30, halt the cutover, fix the root cause, and re-run the affected slice.

Gorgias does not offer a bulk-undo for imports. The audit log under Settings → Audit logs captures customer-created, customer-updated, ticket-created and ticket-updated events for the last 12 months[19](https://flitstack.ai/migrations/helpdesk/gorgias#source-19) [20](https://flitstack.ai/migrations/helpdesk/gorgias#source-20) and is useful for tracing individual problems, but it is not a rollback mechanism.

The practical rollback strategy is: export the source platform's full ticket and customer dataset to S3 or your warehouse before the import starts, stamp every imported ticket with an Import Batch Custom Field, and if catastrophe strikes, bulk-close-and-archive by that batch value and re-run the cleaner pass.

Cutover sequencing per channel: (1) complete the historical import; (2) enable the corresponding channel in Gorgias (email, chat, Facebook, etc.); (3) pause the continuous sync from the source platform; (4) disable that channel on the source-platform side; (5) verify a test message round-trips through the new channel; (6) move to the next channel.

Repeat for every channel before turning off the source platform entirely[12](https://flitstack.ai/migrations/helpdesk/gorgias#source-12). Plan a 48-hour hyper-care window with the migration lead on call, and schedule the source-platform decommission 30 to 90 days post-cutover — never the same day.

## Migration partners and tools

*Official migration partners, e-commerce agencies, iPaaS connectors — what each is good for and how to choose.*

Gorgias maintains a Partners directory at agencies.gorgias.com listing certified agencies tiered as Elite, Premium and Standard, most of which are simultaneously Shopify Plus partners offering end-to-end e-commerce implementation[2](https://flitstack.ai/migrations/helpdesk/gorgias#source-2). Migration-specific endorsement is concentrated around Help Desk Migration (HDM) by Relokia, which is installable directly inside Gorgias at Settings → App Store[3](https://flitstack.ai/migrations/helpdesk/gorgias#source-3), and ClonePartner, which is explicitly validated by the Gorgias team for migration services and runs an engineer-led model with security review and process validation by the Gorgias compliance team.

On the ETL and iPaaS side, Airbyte, Fivetran, Stitch, Celigo, Integrate.io, Workato and Prismatic all ship Gorgias connectors. Their role in a one-time migration is typically the staging layer that pulls source-platform data into a warehouse, the transformation layer that normalises customer emails and tag casing, and — post-migration — the ongoing sync layer that mirrors Gorgias data into your warehouse for BI on top of platforms like Looker, Mode or Hex.

Bruin and the open-source ingestr CLI are common picks for warehouse-first DTC teams that want to copy Gorgias to S3 or Snowflake on a schedule; Workato and Celigo are common where the migration is bundled with broader e-commerce-stack integration rebuilds (ReCharge, Klaviyo, Yotpo, Loop Returns).

Managed-migration cost ranges vary widely. Help Desk Migration's pricing is per-record and scales with dataset size and selected options (inline images, call recordings, translations, custom mappings) — a small-merchant migration of 5,000 tickets often lands in the $300–$1,500 range, while a 250,000-ticket multi-channel migration with attachments and Help Center articles typically runs $5,000–$25,000[3](https://flitstack.ai/migrations/helpdesk/gorgias#source-3). Engineer-led shops like ClonePartner price separately for complex custom-field mappings and historical-data depth. Always run the free 20-ticket Demo Migration before signing scope.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Gorgias migrations and handles the customer email normalisation, ticket and message mapping, public-vs-internal polarity preservation, attachment re-upload, and validation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee based on ticket count and source platform, with separate line items for Help Center article import and historical voice / call-recording depth so the scope is transparent before signature.

This is one of several legitimate paths — the right choice for any given team depends on whether they want the embedded HDM partner app, an official endorsed partner like ClonePartner, an iPaaS-first warehouse-bound approach, or a specialist migration vendor. \[Explore FlitStack →]\(/contact)

In this guide

## Gorgias migration checklist

An atomic, phased punch list for moving tickets, customers, Help Center articles, macros, and rules into a Gorgias helpdesk built around Shopify-first e-commerce support. Typical timeline: 4–10 weeks.

0\. Decide & Plan 9 tasks

- **Document the business reason for moving to Gorgias.** Capture whether the driver is Shopify-native customer + order context, ticket-volume-based pricing, multi-channel inbox consolidation, or AI Agent deflection. The answer shapes which data must come with you versus what can stay archived in the source system.
- **Define migration scope by object: Tickets, Messages, Customers, Users, Tags, Custom Fields (Ticket + Customer), Macros, Rules, Views, Help Center articles + categories, Voice Calls + Recordings, Widgets.** List each object explicitly as in-scope or out-of-scope. Gorgias separates Tickets from Messages (the array of public + internal\_note items inside each ticket), so call out both.*If skipped: Treating Messages as a subordinate field rather than a first-class object causes the public/internal-note polarity to collapse during import.*
- **Decide historical-data depth for tickets, messages, and call recordings.** Gorgias native Zendesk import caps at the most recent 24 months. Pick a hard date floor and document it.*If skipped: An undefined cutoff lets the import job exceed the planned cutover window by days.*
- **Pick the Gorgias plan tier — Starter, Basic, Pro, Advanced, or Enterprise.** Tickets are billed per-ticket on Starter and Basic and bundled on Pro and above. Email import from Gmail or Outlook is Basic+ only. Confirm the chosen tier covers every channel + feature on the must-have list.*If skipped: Discovering a feature gap or per-ticket overage exposure after cutover forces an emergency tier upgrade.*
- **Document compliance posture: SOC 2 Type II, GDPR, DPA execution, EU data-transfer mechanism.** Pull the Gorgias Data Processing Agreement and SOC 2 attestation for the security-review file. Confirm the cross-border transfer mechanism for EU personal data before importing customer profiles.*If skipped: Importing EU personal data without an executed DPA creates a privacy incident on day one.*
- **Assign a single accountable migration DRI plus named owners for data, channels, automation, and end-user enablement.** Capture names, escalation order, and decision authority in one place.
- **Define written success criteria.** Spell out the row counts, open-ticket counts, Help Center article counts, and Statistics baselines that must reconcile before the migration is declared complete.
- **Set the cutover date and the source-system freeze window.** Schedule cutover for a low-volume support window away from peak retail moments. Communicate the freeze to the wider team at least two weeks in advance.
- **Document explicit out-of-scope items.** Examples: spam tickets, deleted tickets, blank tickets, archived KB drafts, social DMs older than the date floor. Recording exclusions kills future scope creep.*If skipped: Unstated exclusions become last-minute escalations when a stakeholder discovers their data did not arrive.*

1\. Pre-Migration Prep 19 tasks

- **Export current record counts from the source for Tickets (open + closed), Messages, Customers, Tags, Macros, Rules, and Help Center articles.** These counts become the reconciliation baseline used in Phase 6.
- **Run email-based dedup on the source customer list.** Normalize emails to lowercase first, then dedup. Gorgias merges customer profiles on email match, so duplicates in the source collapse silently and bring conflicting attributes with them.*If skipped: Conflicting customer attributes survive merge and the wrong values overwrite the correct ones once import completes.*
- **Standardize phone-number formats to E.164 on the source customer list.** Gorgias matches voice-channel callers by normalized phone number. Mixed local and international formats break the match.
- **Flag and resolve tickets in the source with more than 250 comments.** The native Zendesk import in Gorgias splits any ticket above 250 comments into multiple closed tickets. Decide whether to accept the split, archive the long ticket, or summarize before migration.*If skipped: Unflagged long tickets fragment customer history without warning, breaking context for ongoing escalations.*
- **Identify and remove or relabel spam, deleted, and blank tickets in the source.** Deleted and blank tickets are excluded by native import. Confirm any other category you want excluded is filtered or tagged before export.
- **Audit tag taxonomy and consolidate near-duplicates (e.g. "refund", "refunds", "Refund").** Tag normalization upstream is far cheaper than fixing it inside Gorgias views and rule conditions later.
- **Inventory all source custom fields by object type (Ticket vs Customer), data type, and required flag.** Gorgias custom fields support boolean, number, text, and managed types and attach to either Ticket or Customer objects.*If skipped: Importing values into a custom field that does not exist yet silently drops the data on most platforms — Gorgias is no exception.*
- **Provision a Gorgias Sandbox account separate from the production account.** Request the sandbox switch from the demo default. The sandbox absorbs all test loads in Phase 4.*If skipped: Testing imports directly against production pollutes live Statistics and forces a ticket-by-ticket cleanup.*
- **Create all internal Users (agents) with the right Permissions role: Admin, Lead, Agent, or Light Agent.** Only Admins can run native imports. Provision agents in advance so ticket assignment matching works during load.
- **Set account-level Settings: business hours, timezone, language, currency display, and brand voice.** These drive SLA timers, Statistics bucketing, and macro variable rendering after cutover.
- **Create every required Ticket and Customer custom field in Gorgias before any record load.** Use Settings → Ticket fields. Match data types to the source inventory.*If skipped: Loading into a missing custom field drops the value silently — discovered only when an agent opens the ticket and the field is blank.*
- **Create the destination tag taxonomy in Gorgias before any ticket load.** Macros and Rules reference tags by exact name. Pre-creating them prevents on-the-fly tag creation that bypasses the standardization.
- **Configure the Shopify, BigCommerce, or Magento integration in Gorgias and confirm Customer Pages render live order context.** Customer Pages pull order history from the connected e-commerce platform — they do not need to be migrated as data. Connect the integration first so post-import Customer Pages are immediately useful.*If skipped: Without the integration live, agents see migrated tickets but no order context, and the Gorgias-native value proposition disappears.*
- **Connect each in-scope channel: email (direct integration or forwarding), chat widget, Facebook, Instagram, WhatsApp, SMS, Aircall voice.** Each channel is set up under Settings → Channels. Note that the AI Agent feature is positioned as Shopify-only — confirm channel-by-channel feature parity if AI Agent is in scope.
- **Pause all newly connected channels and integrations until cutover.** Connect everything in preparation, but disable the inbound flow until the source is frozen to avoid duplicate or doubled-up tickets across both systems.*If skipped: An active email integration on both source and destination during overlap creates duplicate threads in both inboxes.*
- **Communicate the source-system freeze window to all current agents and stakeholders.** Pick a clear no-writes window and surface it in agent meetings, Slack, and email.
- **Schedule role-based Gorgias training: Agent basics, Admin settings, Macros + Rules authoring.** Pull from the public Gorgias Academy as a starter, then layer in account-specific workflows.
- **Designate first-responder agents who will triage cutover-window issues for the first 48 hours.** Name two primary and two backup responders with explicit on-call windows.
- **Decide and document customer-notification policy for the cutover.** Most teams send no customer-facing message and rely on continuous-sync continuity; some send a brief proactive note. Pick one and document it.

2\. Source Export 12 tasks

- **Export the full Tickets object from the source as CSV or JSON, including every standard and custom field.** Include status, priority, channel, assignee, requester, created\_at, updated\_at, closed\_at, tags, custom field values, and any source identifiers needed as external\_id in Gorgias.
- **Export the Messages collection per ticket, preserving public-vs-internal polarity and chronological order.** Each message needs author, channel, direction (inbound/outbound), sent\_datetime, and the public boolean (Gorgias uses public=true for customer-visible, public=false for internal\_note).*If skipped: Losing the public flag during export turns internal notes into customer-visible messages — a privacy incident waiting to happen.*
- **Export the Customers object with email (primary match key), name, phone (E.164), language, and all custom fields.** Include the source customer ID as external\_id so upsert keying works on re-runs.
- **Export agent / Users with email, name, role, and reporting structure.** User exports drive agent-mapping decisions in Phase 3.
- **Export Tags as a distinct list with counts.** Tag counts confirm taxonomy decisions and surface near-duplicates one last time before import.
- **Export Macros from the source with body text, placeholders, and tag associations.** Gorgias Macro CSV import accepts four columns (name, body\_text, tags, id) and only UTF-8 encoding. Macros are typically rebuilt, not migrated literally — variable syntax differs across platforms.*If skipped: Importing macros without translating variable syntax produces blank or broken placeholder text on every send.*
- **Export source automation rules (Triggers, Automations, Flows) as configuration screenshots or JSON.** Gorgias splits automation into three engines: Rules (event-driven), AutoResponders (out-of-hours/holiday replies), and Macros (canned responses with variables). All three are rebuilt in Gorgias, not migrated — the export is documentation, not load data.*If skipped: Treating automation as migratable wastes a week before the team realizes everything must be rebuilt by hand.*
- **Export Help Center articles, categories, and translations with body HTML, status (draft/published), author, and folder structure.** If migrating from Zendesk, HelpDocs, or Re:amaze, Gorgias has a direct importer. From other sources, prepare a CSV per Gorgias's article-import spec. Images and other media are handled separately.
- **Export attachments as binary files plus a manifest mapping each file to its ticket and message.** Gorgias's ticket message body\_text and body\_html are capped at 1 MB per message; the cap does not apply to attachments. Keep binaries separate from message bodies.*If skipped: Embedding base64 attachments inline pushes message bodies over the 1 MB cap and truncates the text content on import.*
- **Export voice call recordings as audio files with a manifest mapping each recording to its ticket.** Voice calls become ticket attachments in Gorgias. Confirm file format and retention policy match the source.
- **Capture configuration screenshots of source Views, SLA policies, dashboards, and CSAT survey settings.** These are rebuilt in Gorgias's Views, Statistics, and survey integrations — they do not transfer.
- **Document the exact UTC timestamp of every export for delta calculation at cutover.** The delta between Phase 2 timestamps and the cutover freeze defines what must be re-exported in Phase 5.

3\. Transform & Map 25 tasks

- **Build a master mapping spreadsheet covering every source field and its Gorgias destination.** One row per source field: source object, source field, source type, Gorgias object (Ticket, Customer, Message), Gorgias field, Gorgias type, transformation rule, required flag, nullability.
- **Resolve status mapping between source and Gorgias ticket statuses (open, closed).** Gorgias native Zendesk import treats any non-closed status as open; pending and on-hold tickets do not retain those nuances. Decide explicitly which source statuses map to closed and which to open.*If skipped: Pending tickets imported as open inflate the open-ticket count and skew Statistics from day one.*
- **Set upsert keys per object: external\_id for Tickets, email for Customers, source-id for Macros.** Idempotent upserts are required so re-runs after a partial failure do not duplicate records.
- **Decide handling for source fields without a Gorgias equivalent: drop, concatenate into the ticket's internal note, or create a new custom field.** Document the decision per field so reviewers can audit.
- **Map agent identities from source emails to Gorgias User IDs.** Build a lookup file. For agents who left the team, decide whether to assign their historical tickets to a single "data migration" user or to a current team lead.*If skipped: Unmapped agent IDs default to an unhelpful placeholder and ownership reports become unusable.*
- **Convert all datetime fields to ISO-8601 with explicit UTC offset.** Gorgias stores timestamps in UTC. Mixed timezone representations create off-by-hours errors in SLA Statistics.*If skipped: Local-time strings imported as UTC misplace ticket creation times by up to a full day on either side of date boundaries.*
- **Re-encode all CSVs as UTF-8 without BOM.** The Gorgias Macro CSV import explicitly requires UTF-8. Apply the same encoding standard to every other CSV to avoid mid-import character corruption.*If skipped: Latin-1 or Windows-1252 encoding produces mojibake in customer names and message bodies — visible to customers on the first reply.*
- **Truncate ticket subject lines to 998 characters maximum.** Gorgias caps ticket subject length at 998 characters as of Sep 2024. Anything longer is rejected on load.
- **Truncate any message body that exceeds 1 MB in body\_text or body\_html.** The 1 MB cap was enforced Jan 2023. Truncate intelligently — keep the most recent conversation tail and move the older bulk to an attached file.*If skipped: Untruncated long bodies fail to load and stall the import job.*
- **Normalize tag values to lowercase, hyphen-separated, ASCII-only.** Mixed-case tags create duplicate Tag records in Gorgias because tag matching is case-sensitive in some contexts.
- **Decide and implement strategy for original ticket created\_at timestamps.** Gorgias's native Zendesk import preserves original timestamps. Confirm any custom import path also sets created\_datetime explicitly rather than letting the load path stamp the import time.*If skipped: Re-stamped tickets all share the same created date and destroy Statistics trend analysis going forward.*
- **Decide and implement strategy for ticket ownership during import.** Options: (a) best-match by agent email, (b) assign to a "data migration" user, (c) leave unassigned. Pick one per ticket cohort and document.
- **Decide strategy for the audit log gap.** Gorgias retains audit log events for 12 months only (per Feb 2026 policy). Source audit history older than 12 months cannot be replicated into the destination audit log. Export and archive the source audit log separately for compliance.*If skipped: Skipping the separate archive means source audit history is lost forever once the source is decommissioned.*
- **Decide strategy for attachments: inline binary upload to Gorgias or link out to external storage.** Inline upload preserves attachment search; external links keep storage costs down.
- **Reassemble ticket history as Tickets plus an ordered Messages array, preserving public-vs-internal polarity on every message.** Gorgias's data model is Ticket → Messages\[]. Each message has a public boolean: true for customer-visible replies, false for internal\_note. Build the transform to emit a Ticket payload plus a Messages array in chronological order with the public flag set correctly per message.*If skipped: Flipping the public flag on internal notes leaks confidential agent discussion to the customer on the next ticket view.*
- **Migrate Help Center articles + categories + translations as a tree, preserving folder structure and per-language variants.** If the source is Zendesk, HelpDocs, or Re:amaze, use the Gorgias direct importer to retain status (draft/published). Otherwise, follow the Gorgias article-import CSV spec; re-upload images, GIFs, and inline media separately as the importer handles them out-of-band.*If skipped: Skipping translations leaves non-primary-language shoppers with no help content on day one.*
- **Rebuild Macros in Gorgias rather than migrating source automations literally.** Use the CSV macro import (columns: name, body\_text, tags, id; UTF-8 only; tags must already exist) for bulk creation, then layer Gorgias-native variable syntax (e.g. {{ticket.customer.first\_name}}) by hand. Macro CSV import does not preserve formatting.*If skipped: Importing macros with source variable syntax produces literal {{handlebars}} strings sent to customers.*
- **Rebuild Rules (event-driven automation) using source rule documentation as the requirements input.** Gorgias Rules trigger on ticket events (created, updated, message added) and execute actions (assign, tag, set field, apply macro). Source triggers and automations do not migrate; rebuild each one in Settings → Rules.
- **Rebuild AutoResponders for out-of-hours, holiday, and overflow auto-replies.** AutoResponders are a separate engine from Rules and Macros. Configure them in Settings under the auto-response area, mapped to business hours.
- **Reset SLA timers on migrated tickets and accept that historical SLA metrics restart at cutover.** Gorgias's Statistics begin from cutover for migrated tickets — historical SLA history from the source does not transfer cleanly. Document this as a known break in trend reporting and archive source SLA reports as PDFs for the prior period.*If skipped: Stakeholders expecting continuous SLA trendlines will see a sudden discontinuity and assume the migration broke reporting.*
- **Decide and document the CSAT history fallback.** CSAT scores typically do not transfer between helpdesks. Export source CSAT history as a flat report, archive it, and plan to start fresh CSAT collection in Gorgias via the chosen survey integration after cutover.*If skipped: Reporting comparisons against last quarter's CSAT will be impossible without the archived source export.*
- **Map multi-channel inbound: email (direct or forwarding), chat widget, Facebook, Instagram, WhatsApp, SMS, Aircall voice + phone.** Each channel is a separate connection in Gorgias Settings → Channels. Voice channels via Aircall require a separate Aircall account and integration. Confirm channel parity against the source inventory.*If skipped: A forgotten channel (often SMS or a secondary Facebook page) means inbound traffic on that channel keeps hitting the source after cutover.*
- **Configure Shopify, BigCommerce, or Magento as a live integration so Customer Pages pull order history natively.** Customer order context is not migrated as data — it is pulled live by the e-commerce integration on each ticket view. Confirm the integration is live and authenticated before cutover.*If skipped: Without the live integration, Customer Pages render with no order context and agents must fall back to manual lookups in the e-commerce admin.*
- **Plan voice call recording migration as ticket attachments.** Voice recordings from the source attach to their tickets as audio files. Confirm the file size and retention align with compliance requirements.
- **Plan app integrations rebuild: Klaviyo, Yotpo, Recharge, Aircall, and any custom integrations.** Each app is reinstalled in Gorgias App Store and reauthorized. Custom integrations are recreated in Settings → Integrations using the source configuration as the requirements input.*If skipped: Forgetting to rewire Klaviyo or Recharge breaks abandoned-cart workflows and subscription-management tickets on day one.*

4\. Sandbox Test Migration 12 tasks

- **Load a 1–5% representative sample of each object into the Gorgias sandbox using the chosen import path.** Sample must include open and closed tickets, multi-message threads, internal notes, attachments, tagged tickets, and at least one ticket per channel type.
- **Validate field-by-field on 10 random sandbox tickets that values arrived correctly.** Open each ticket and verify subject, status, requester, assignee, tags, custom fields, and message order.
- **Confirm the public-vs-internal polarity on every message in the sample.** Spot-check 20 messages flagged internal in the source: are they internal\_note (public=false) in Gorgias? Spot-check 20 customer-visible messages: are they public=true?*If skipped: A polarity bug discovered in production leaks internal commentary to customers on every reopened ticket.*
- **Test attachment upload and confirm files render in Gorgias ticket view.** Test at least one .png, one .pdf, and one large file approaching but under 1 MB body cap.
- **Test datetime handling: load tickets with timestamps in the past, near present, and at DST transitions.** Verify created\_datetime, updated\_datetime, and closed\_datetime all render correctly in the agent UI and in Statistics.*If skipped: Hidden timezone bugs surface only at DST boundaries — catch them in the sandbox, not in production.*
- **Test special characters: emoji, RTL languages, accented characters, em-dashes, CJK characters in subjects and message bodies.** Encoding bugs surface here before they hit customer-facing messages.
- **Test customer dedup on email match.** Import two customers with the same email but different names. Confirm Gorgias merges them and decide which attributes win.*If skipped: Surprise merges in production overwrite the wrong customer name on the first ticket received post-cutover.*
- **Time a full-volume sample load and extrapolate to production throughput.** Native Zendesk import averages 720 tickets per hour. Multiply your ticket count by your per-ticket work and confirm the result fits in the cutover window.*If skipped: Discovering the cutover window is too short on the day of cutover forces an emergency reschedule.*
- **Test Macro CSV import with the four required columns (name, body\_text, tags, id) in UTF-8.** Confirm tags referenced in the CSV already exist in Gorgias — the import fails silently otherwise.*If skipped: Missing tags abort the macro import without a clear error and you discover incomplete macro library on first agent shift.*
- **Test Help Center article import with at least one multilingual article.** Confirm translation linkage and folder placement match the source structure.
- **Have a senior agent or support lead spot-check 25 random sandbox tickets for correctness.** Domain experts catch issues automated reconciliation misses — wrong tag context, ambiguous status mapping, missing custom field values.
- **Get written sandbox sign-off from the migration sponsor before proceeding to Phase 5.** No production cutover without explicit sign-off on the sandbox results.

5\. Production Cutover 9 tasks

- **Confirm source-system freeze: no new tickets, no agent replies, no admin changes for the agreed window.** Verify by checking the source's audit log for activity in the last hour.*If skipped: Source writes during cutover are invisible to the export and become permanent data loss.*
- **Take a final full export of source data covering the delta since the Phase 2 baseline.** Re-run the same export scripts with a new timestamp filter to capture everything since the last export.
- **Disable all destination Rules, AutoResponders, and active integrations on the Gorgias side before loading data.** Loading tickets with Rules enabled causes Gorgias to fire customer-facing AutoResponders and agent assignments on every imported ticket — a notification flood.*If skipped: Forgetting to pause Rules generates thousands of misleading customer emails within minutes of the load starting.*
- **Load objects in dependency order: Users → Customers → Tags + Custom Fields → Tickets → Messages → Attachments.** Parent objects must exist before children. Gorgias rejects ticket creation against a non-existent customer.
- **Use idempotent upserts keyed off external\_id (Tickets) and email (Customers) on every load.** If a step fails partway, re-running with the same keys updates instead of duplicating.*If skipped: Non-idempotent loads duplicate every record on retry and the only fix is a full account reset.*
- **Capture import job IDs, row counts, and full error logs for every load step.** Logs become the audit trail for the Phase 6 reconciliation.
- **Cross-check destination row counts against source row counts after each step before moving to the next.** Catch shortfalls before they compound across multiple object types.
- **If a load step fails partway: stop, diagnose, fix the transform, re-run idempotently.** Do not push through with partial data — partial loads create corrupt customer histories.
- **Re-enable Rules, AutoResponders, and integrations only after all data loads complete and Phase 6 reconciliation begins.** Confirm by checking the Settings → Rules toggle and the Channels status page.

6\. Validate 20 tasks

- **Compare total Ticket count: source vs Gorgias. Investigate any delta over 0.1%.** Account for the documented exclusions (deleted, blank, spam) when comparing.
- **Compare total open Ticket count: source open vs Gorgias open.** Open-ticket count is the most visible Statistics metric — it must reconcile exactly within the agreed status mapping.*If skipped: An off-by-thousands open count signals a status-mapping bug and erodes trust in every downstream Statistics number.*
- **Compare total Customer count and confirm dedup behaved as expected.** Acceptable shrinkage from source to Gorgias = number of duplicate-email rows collapsed during merge.
- **Cross-check 30 randomly selected tickets field-by-field between source and Gorgias.** Sample must span channels, statuses, and date ranges. Verify subject, status, requester, assignee, tags, custom fields, and message count.
- **Verify all in-scope custom field values arrived intact on a sample of 50 tickets and 50 customers.** Open each record in the Gorgias UI and inspect the custom-field panel.
- **Compare aggregate message count per ticket on a 50-ticket sample.** Missing or duplicate messages signal a Messages-array transformation bug.*If skipped: A 5% message-loss rate is invisible at the ticket level but breaks customer history end-to-end.*
- **Verify a sample of Customer → Ticket linkages match the source.** Pull 20 customer profiles, count their tickets in Gorgias, and compare to source.
- **Verify the public-vs-internal polarity on 100 randomly sampled messages.** Open each message in the agent UI and confirm internal\_note styling on internal messages and standard styling on public ones. Polarity bugs surface only by sampling.*If skipped: Even a 0.1% polarity-flip rate is a privacy breach — sample wide enough to catch it.*
- **Verify Help Center articles render correctly, including translations, images, and folder structure.** Browse the public Help Center as a logged-out user. Confirm 20 random articles render and that media displays.
- **Verify attachments are linked to the right tickets and open without error.** Pull a random 30 attachments across file types and click each one.
- **Verify Customer Pages render live order context from the connected Shopify, BigCommerce, or Magento store.** Open 10 random customer profiles and confirm the order history pane populates.*If skipped: If Customer Pages are blank, the e-commerce integration is misconfigured and the Gorgias-native value is offline.*
- **Send a test inbound on every connected channel: email, chat, Facebook, Instagram, WhatsApp, SMS, voice.** Confirm each channel routes to Gorgias and creates a ticket. Reply outbound and confirm the customer receives it.
- **Test every rebuilt Macro by applying it to a test ticket.** Confirm variable substitution renders correctly (no literal {{handlebars}}) and tags apply.
- **Test every rebuilt Rule by triggering its conditions on a test ticket.** Walk through each Rule's trigger event and confirm the action fires (assign, tag, macro apply).
- **Test every rebuilt AutoResponder.** Send an inbound during the configured out-of-hours window and confirm the auto-reply sends.
- **Verify the Gorgias audit log captures the import events.** Settings → Audit logs shows the last 12 months of events. Confirm import-related activity is captured and document anything older as archived elsewhere.
- **Confirm GDPR + SOC 2 compliance posture: DPA on file, data-transfer mechanism documented, retention policy confirmed.** Pull the latest Gorgias DPA and SOC 2 attestation; file alongside the migration project record.
- **Have 3–5 frontline agents validate their day-to-day workflows in Gorgias against the migrated data.** Cover: searching tickets, replying to a ticket, applying a macro, escalating a ticket, opening a customer profile.
- **Document any data issues surfaced by UAT and decide which are blockers vs deferred fixes.** Blockers must be resolved before sponsor sign-off; deferred items go to the Phase 7 cleanup list.
- **Get written sign-off from the migration sponsor before proceeding to Phase 7.** Sign-off should reference the reconciliation numbers and the UAT results.

7\. Post-Migration Cleanup 11 tasks

- **Announce go-live to all agents with login URL, training resources, and the first-responder escalation contact.** Pin the announcement in the team chat for the first 14 days.
- **Run final role-based training sessions: Agents, Admins, Reporting users.** Pull from Gorgias Academy plus account-specific recordings of the rebuilt workflows.
- **Set the source system to read-only and announce the read-only date to the team.** Read-only state preserves the source for forensic lookup while preventing accidental writes that would diverge from Gorgias.
- **Rebuild Statistics views, dashboards, and saved reports in Gorgias.** Gorgias's Statistics + Performance + Revenue Tracking dashboards do not transfer from the source — rebuild against the migrated data.*If skipped: Without rebuilt dashboards, leadership has no visibility into the new system and falls back to source reports that no longer match reality.*
- **Re-establish all third-party integrations: Klaviyo, Yotpo, Recharge, Aircall, custom integrations.** Each integration is reinstalled from Gorgias App Store or rebuilt as a custom integration in Settings → Integrations.
- **Decommission any source-side integrations to avoid duplicate notifications or auto-replies.** Disable each source-side Shopify, email, or chat integration explicitly — do not assume disabling the source app suffices.*If skipped: An orphaned source-side integration keeps firing for weeks and fragments customer history across both platforms.*
- **Schedule a 30-day post-migration retrospective with the migration team.** Capture what went well, what surprised the team, and what to do differently next time.
- **Document the source-system decommission date (typically 90 days after cutover).** Decommission must come after the last retention window closes. Confirm with legal and finance that no compliance hold blocks decommission.
- **Archive the source-system data exports to long-term cold storage.** Tickets, customers, audit log, attachments, and CSAT history — all archived in case of later forensic need.
- **Archive the source audit log separately, given the Gorgias 12-month audit retention limit.** The audit log is the only artifact that cannot be reconstructed later — store it on durable, access-controlled storage.*If skipped: Losing the source audit log eliminates the only record of who did what before cutover.*
- **Close out the migration project formally: final status report, lessons learned, project closure memo.** File alongside the sponsor sign-off and the reconciliation report.

Questions, answered

## Migrating to Gorgias: questions

How long does migration to Gorgias take?

A small-merchant migration with under 5,000 tickets via the native Zendesk Importer or Help Desk Migration app runs one to three business days end-to-end. A multi-channel brand with two years of Zendesk history of around 250,000 tickets runs roughly two weeks because the importer averages 720 tickets per hour.

Can I migrate from Zendesk to Gorgias?

Yes — Gorgias ships a native Zendesk Importer at Settings, Import data that pulls tickets, macros, users, tags and ticket fields. Up to two years of recent data import; tickets with more than 250 comments split into multiple closed tickets; statuses collapse to open or closed only.

Can I migrate from Freshdesk, Help Scout, or Intercom to Gorgias?

Yes, via the Help Desk Migration app installable from Settings, App Store inside Gorgias. It supports 80+ source helpdesks including Freshdesk, Help Scout, Intercom, Kustomer, Re:amaze and Zoho Desk, handles attachments, custom fields and Help Center articles, and offers a free 20-ticket demo before paid migration.

Does Gorgias preserve original timestamps on import?

Yes for tickets and messages through the native Zendesk Importer or the HDM partner app — created\_datetime values from the source are preserved on import. The Gorgias audit log only captures events from import-day forward, and audit retention caps at 12 months as of February 25, 2026.

What's the difference between using the native importer and the HDM app for Gorgias?

The native Zendesk Importer is admin-only inside the UI, averages 720 tickets per hour, caps at two years and 250 comments per ticket, and handles continuous sync. The Help Desk Migration app covers 80+ other source helpdesks with a free Demo Migration and a paid full migration that preserves relationships.

Can I migrate Macros and Rules to Gorgias?

Macros migrate via the Macro CSV import at Settings, Productivity, Macros with 4 columns: name, body\_text, tags, id; tags referenced must exist first. Rules, AutoResponders and Flows do not migrate and must be rebuilt manually in Settings, Automation from a tracked spreadsheet of source-platform automations.

What happens to ticket history and conversation threads during migration?

Ticket bodies and message threads transfer with their original timestamps, sender references, attachments and the public-vs-internal-note flag. Tickets over 250 comments split into multiple closed tickets via the native importer. Source statuses richer than open or closed collapse onto Gorgias's binary, with the missing state typically modelled as a tag.

Is there an undo or rollback for Gorgias imports?

No native bulk-undo. The Gorgias audit log under Settings, Audit logs captures customer and ticket events for up to 12 months and helps trace individual problems, but it is not a rollback tool. The practical strategy is to stamp every imported ticket with an Import Batch Custom Field for selective cleanup.

## Sources

1. [Gorgias Partners directory](https://agencies.gorgias.com/)
2. [Help Desk Migration — Gorgias Help Center](https://docs.gorgias.com/en-US/help-desk-migration-398565)
3. [Create a custom field — Gorgias documentation](https://docs.gorgias.com/)
4. [Import and export Macros — Gorgias Help Center](https://docs.gorgias.com/en-US/import-and-export-macros-207786)
5. [Limit ticket message body size to 1MB — Gorgias changelog](https://docs.gorgias.com/)
6. [Gorgias does helpdesk well — r/EntrepreneurRideAlong](https://www.reddit.com/r/EntrepreneurRideAlong/comments/1t3hkbi/uncommon_opinion_but_the_gorgias_alternative/)
7. [Zendesk migration 101 — Gorgias Help Center](https://docs.gorgias.com/en-US/zendesk-migration-101-214413)
8. [Gorgias Partner Portal & Sandbox Accounts](https://partners.gorgias.com/)
9. [Gorgias resource catalogue](https://docs.gorgias.com/)
10. [Gorgias is Now SOC 2 Type II Certified](https://www.gorgias.com/blog/gorgias-is-soc-2-type-ii-certified)
11. [Integration resources — Gorgias Help Center](https://docs.gorgias.com/en-US/articles/integration-resources-18370)
12. [View an audit log of changes to your account — Gorgias Help Center](https://docs.gorgias.com/en-US/view-an-audit-log-of-changes-to-your-account-81841)
13. [Gorgias changelog (audit retention, subject cap, body cap)](https://docs.gorgias.com/)
14. [Upload files — Gorgias documentation](https://docs.gorgias.com/)
15. [Transfer Gorgias account ownership](https://docs.gorgias.com/en-US/account-ownership-196940)

Get a quote

## Moving to Gorgias?

Tell us where your data lives today and roughly how much there is. We scope the migration and the Gorgias setup with you, then send a quote.

[Get a quote](https://flitstack.ai/contact)
