Skip to content
Get a quote

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.

By

From Your system
DestinationGorgias
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 APIOAuth 2.0 or API key
Rate limits40 req/20s (API key) or 80 req/20s (OAuth2); Enterprise uses 10-second window
ObjectSupportNote
TicketsfullTickets 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.
CustomersfullCustomers 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.
AgentsfullAgents 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.
GroupsfullGroups (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.
MacrosfullMacros 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.
RulesfullRules 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.
ViewsmappedViews 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 FieldsmappedCustom 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 CategoriesfullTop-level KB categories with name, position, and translations. We migrate category hierarchy and ordering, and preserve translation content for each enabled locale.
Knowledge Base ArticlesfullKB 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.
ConversationsfullConversations 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.
AttachmentsmappedFile 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 SurveysfullCSAT 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.
TagsmappedTags 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.
SettingsmappedAccount-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-switch9. 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 shape12. 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 tool12, 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 Store3.

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 two16.

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.

ObjectWhat it storesRequiredTier
TicketsA single customer issue with a thread of messagesCustomer reference (id or email), channel, at least one messageAll plans
Messages (TicketMessage)Individual replies, notes, or system events inside a ticketbody_text or body_html, sender, channel; max 1 MB per message bodyAll plans
CustomersEnd-user contact records — name, channels, addresses, custom fieldsAt least one channel (email, phone, social handle)All plans
Users (Agents)Internal team members who handle ticketsEmail, name, roleAll plans; seat counts gated by plan
TagsString labels applied to tickets for grouping and Rule conditionsName (case-sensitive on import)All plans
Custom FieldsPer-Ticket or per-Customer typed metadataobject_type (Ticket or Customer), label, definitionAll plans
MacrosPre-written reply templates with variables and actionsname, body_text, tagsAll plans; advanced actions on higher tiers
RulesTrigger-based automation: when X, then Y on ticket lifecycleCondition tree, action list — rebuilt manually, not importedAll plans; rule count gated by plan
ViewsSaved filter queries over tickets (Unassigned, Urgent, etc.)Name, filter definitionAll plans
Help Center ArticlesKnowledge base articles, categories, translationsTitle, body, category, statusBasic plan and above
Voice CallsCall records linked to tickets (Aircall integration)Linked Ticket id, direction, timestampPlans with Voice add-on
Integrations / WidgetsCustom HTTP integrations and right-sidebar widgetsRebuilt manually in Settings → IntegrationsAll 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 loader4.

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 reconciliation4. Custom Fields exist for two object_type values only — Ticket and Customer — and the supported definition data types are boolean, number, and text4.

Field typeLimitNotes
text1 to 1024 chars (label); body variesFree-form string; the workhorse type for source id round-trip
numberSigned numericNo formula type — calculations rebuilt outside Gorgias
booleantrue / falseDefaults configurable per field
Single-select / Multi-selectDefined in definition payloadPicklist values stored as strings — case-sensitive on Rule match
Required flagboolean per fieldDefaults to false; required fields block ticket close in some UI flows
Custom field priority0 to 5000Controls display order on ticket and customer sidebar4
Macro bodyCSV import: UTF-8 only, formatting not preservedMacro import supports 4 columns: name, body_text, tags, id6
Ticket message body1 MB per body_text or body_htmlBodies over 1 MB return HTTP 400 on create/update; pre-existing oversized messages are truncated7

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 internally16.

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-upload7.

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 side4.
  • 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 tickets12. Help Desk Migration's third-party tool has no hard time cap but bills per record3. 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 [email protected] with the account URL to convert to the partner plan for full-fidelity testing15.
  • 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 ownership22. 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 reused4.
  • 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 twice12.
  • 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 weeks12. 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 forward12. 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 hour12.

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 duplicate12.

Help Desk Migration (HDM) partner app

Built by Relokia and accessed inside Gorgias at Settings → App Store → All Apps → Help Desk Migration3. 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 relationships3.

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 options3.

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, 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 them21.

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

Common source → Gorgias Customer mapping
SourceDestinationNote
emailchannels[type=email].addressLowercased on import; primary upsert match key for inbound tickets
first_name / last_namefirstname / lastnameCombined into name if name is missing on payload
phonechannels[type=phone].addressNormalise to E.164 before import
social handle (FB/IG/WhatsApp)channels[type=facebook|instagram|whatsapp].addressMulti-channel customers consolidate onto one record
source platform idexternal_idFirst-class field for round-trip and reconciliation4
shopify customer idSet via Shopify integration enrichment post-importThe Shopify integration matches by email at runtime
custom contact fieldsCustom Fields with object_type=CustomerPre-create on the Customer object before import4

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 body7), 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.

Common source → Gorgias Ticket + Message mapping
SourceDestinationNote
ticket id (source)Custom Field on Ticket (text)Use for reconciliation and cross-system links; Gorgias assigns its own id
subjectsubjectMax 998 chars; longer subjects truncated19
status (open/pending/solved)status (open/closed)Gorgias has open or closed only; pending/on-hold collapse to open12
channel (email/chat/voice/social)channelMap to email, chat, facebook, instagram, whatsapp, sms, phone, contact-form
assignee_idassignee_user.idResolve agent email/id against pre-provisioned Users
tags[]tags[]Case-sensitive — tags used in Rule conditions must match exactly
created_atcreated_datetimeISO-8601; Gorgias preserves on import via the HDM tool
comments[].bodymessages[].body_html or body_textMax 1 MB per message7; longer messages return HTTP 400
comments[].privatemessages[].public (inverted)private:true → public:false (internal note); preserve polarity
comments[].author_idmessages[].senderCustomer reference for customer messages, User reference for agent
attachments[]Upload separately then attach to message21Multi-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. 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 created6.

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 lockstep12. 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 ticket12. 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 attachment21. 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 HDM12. 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 change1920. 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.

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.
  • 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 chains12.
  • 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 structure6.
  • 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 months1920 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 entirely12. 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 implementation2. Migration-specific endorsement is concentrated around Help Desk Migration (HDM) by Relokia, which is installable directly inside Gorgias at Settings → App Store3, 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,0003. 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)

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 & Plan9 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 Prep19 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 Export12 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 & Map25 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 Migration12 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 Cutover9 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. Validate20 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 Cleanup11 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.

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