Gorgias to Zendesk Migration Guide (2026) | Step-by-Step

A Gorgias to Zendesk migration is moderate complexity for the data layer but high complexity for the e-commerce workflow layer. Ticket history, customers, tags, and custom fields migrate cleanly via the Zendesk Ticket Import API (POST /api/v2/imports/tickets) with original timestamps preserved. (developer.zendesk.com) The hard parts are the e-commerce integration gap — Gorgias's native Shopify integration does not exist natively in Zendesk and must be replaced with marketplace apps that offer less depth — the macro rewrite (every macro using e-commerce variables must be audited and rewritten), and the autoresponder redesign (Gorgias's intent-based auto-replies must be rebuilt from multiple Zendesk components). Realistic timeline for a typical team (20 agents, 100K tickets): 3–6 weeks including planning, integration evaluation, test migration, and validation.

For a broader pre-migration framework, see the Zendesk Migration Checklist. For a platform comparison before committing, see Zendesk vs Gorgias (2026): The Operations Lead's Decision Matrix.

Why E-Commerce Teams Move from Gorgias to Zendesk

A Gorgias to Zendesk migration is a move from an e-commerce-specialized helpdesk to a general-purpose, enterprise-grade platform. Teams make this switch when they outgrow e-commerce-only support and need capabilities Gorgias does not offer. (docs.gorgias.com)

The most common triggers:

• Multi-department routing and B2B support. Gorgias is built for D2C e-commerce. Teams adding SaaS product support, wholesale, or internal IT support need Zendesk's group-based routing, ticket forms per department, and custom ticket statuses (Suite Enterprise+).
• Advanced SLA management. Zendesk supports multiple SLA policies with business-hours-aware targets, priority-based escalation, and breach notifications. Gorgias has no equivalent SLA engine.
• Zendesk Guide. A mature knowledge base with categories, sections, custom themes, community forums, and multilingual support — far beyond Gorgias's flat FAQ widget.
• Zendesk Explore. Custom reporting with calculated metrics, cross-dataset queries, and scheduled dashboards. Gorgias's built-in analytics are limited to pre-built views.
• Marketplace ecosystem. Zendesk's marketplace has 1,500+ apps. Gorgias's integration library is significantly smaller.
• Compliance requirements. Zendesk offers FedRAMP and HIPAA-eligible configurations on Enterprise plans. Gorgias does not offer either.
• Organizational standardization. The company already uses Zendesk for other departments and wants a single platform for consolidated reporting and agent management.

The trade-off is real: you gain enterprise breadth and configurability but lose Gorgias's native e-commerce depth. That trade-off defines every decision in this migration.

Gorgias to Zendesk Object and Field Mapping

The core data model translation is straightforward. Map it wrong and the import fails silently or produces garbage data. (developer.zendesk.com)

• Gorgias Tickets → Zendesk Tickets. One-to-one. Gorgias has two statuses: Open and Closed. Zendesk has five: New, Open, Pending, Solved, Closed (plus custom statuses on Suite Enterprise+). Map Gorgias "Open" → Zendesk "Open." Map Gorgias "Closed" → Zendesk "Solved" for recently-closed tickets (allows the customer to reopen by replying) or "Closed" for older archived tickets. Define a cutoff date for this split (e.g., tickets closed within the last 90 days → Solved; older → Closed). If a Gorgias ticket is snoozed with a wake time in the future, map it to Zendesk "Pending" and create an automation to reopen it based on a custom date field.

• Gorgias Ticket Messages → Zendesk Ticket Comments. Each message becomes a comment. Preserve the from_agent flag (agent replies → public comments from agent user; customer messages → public comments from end-user), internal notes → private comments, HTML body, and created_at timestamp. Watch Zendesk's 5,000-comment limit per ticket — tickets exceeding this cap must be split or truncated before import. (developer.zendesk.com)

• Gorgias Customers → Zendesk End Users. Core fields (name, email, phone) map directly. E-commerce data (Shopify customer ID, LTV, order count) has no native Zendesk fields — store in custom user fields or omit if the Zendesk Shopify app will surface it dynamically. Zendesk end-users are unique by email; dedup Gorgias customers before import. (support.zendesk.com)

• Gorgias Tags → Zendesk Tags. Both support free-form tags, but Zendesk tags must be lowercase with underscores (no spaces). Normalize all tags before import. Decide whether to preserve Gorgias's auto-generated intent/sentiment tags (prefix with gorgias_intent_ to distinguish from Zendesk Intelligent Triage tags) or discard them. (support.zendesk.com)

• Gorgias Custom Fields → Zendesk Custom Ticket Fields. Type matching required. For dropdowns, enumerate and pre-create all values in Zendesk before importing tickets. Zendesk macros can only update ticket fields that are present on the active ticket form.

• Gorgias Teams → Zendesk Groups. Direct mapping for agent grouping and ticket routing.

• Gorgias Agents → Zendesk Agents. Recreate profiles. Map roles: Admin → Admin, Lead Agent → Agent (with elevated permissions), Agent → Agent, Lite Agent → Light Agent.

• Gorgias Views → Zendesk Views. Must be recreated manually. Cannot be migrated programmatically. (docs.gorgias.com)

• Gorgias Rules → Zendesk Triggers + Automations. Must be rebuilt manually. Event-driven rules become Triggers; time-driven rules become Automations.

• Gorgias Macros → Zendesk Macros. Text-only macros migrate directly. Macros with Shopify variables break — see the macro rewrite section below.

What has no clean equivalent: Gorgias revenue statistics (docs.gorgias.com), macro e-commerce variables ({{last_order.name}}, {{last_order.tracking_url}}), native Shopify order actions (refund/cancel/edit within the helpdesk), proactive chat campaigns with e-commerce triggers, Gorgias Convert, and autoresponders with intent-based auto-replies using order data.

For guidance on what data to migrate vs. leave behind, see the Help Desk Data Migration Playbook.

What Happens to Your Shopify Integration When You Leave Gorgias?

This is the #1 concern for e-commerce teams and the single biggest functional trade-off in a Gorgias to Zendesk migration.

The honest answer: Gorgias's native Shopify integration does not exist in Zendesk. Zendesk connects to Shopify via a marketplace app that provides overlapping but narrower functionality.

What agents keep: The official Zendesk Shopify app displays order history, customer details, billing/shipping addresses, fulfillment status, and shipment tracking in a sidebar widget. Agents can also process refunds and cancellations for unfulfilled orders directly from the sidebar. (support.zendesk.com)

What agents lose or what requires workarounds:

• In-ticket order editing. Gorgias lets agents edit orders (modify line items, update shipping address) without leaving the ticket. (docs.gorgias.com) The standard Zendesk Shopify app does not support order editing. Third-party apps like agnoStack offer order modification — agnoStack is the only Zendesk connector that lets agents modify unshipped order line items directly within Zendesk. (agnostack.com)

• Macro variables with order data. Gorgias macros using {{last_order.name}}, {{last_order.tracking_url}}, or {{customer.total_spent}} have no Zendesk equivalent. Agents must manually copy order data from the sidebar, or the team must build a custom integration that populates Zendesk custom ticket fields with Shopify data. (docs.gorgias.com)

• Revenue attribution. Gorgias tracks revenue generated by support interactions. Zendesk has no equivalent. This metric must be replaced with Shopify analytics, a BI tool (Looker, Metabase, etc.), or accepted as a lost metric.

• Proactive chat campaigns with e-commerce triggers. Gorgias triggers chat messages based on cart value, product page, or checkout page. Zendesk's proactive messaging does not have native Shopify cart awareness — its native criteria are page URL, page title, and visit history, not cart value. (docs.gorgias.com)

• Multi-store Shopify configurations. If your Gorgias instance connects to multiple Shopify stores, the Zendesk Shopify app supports multi-store setups but each store requires separate configuration and the sidebar displays data per-store. Verify the agent UX for multi-store workflows before go-live — the experience may require more clicks than Gorgias's unified view.

How to Rewrite Gorgias Macros and Rules for Zendesk

The macro rewrite is the most common time overrun in Gorgias to Zendesk migrations. For a typical e-commerce team, 30–50% of macros use Shopify variables. These all break in Zendesk. (docs.gorgias.com)

Classify every Gorgias macro into three types:

• Type A — Text-only macros (no e-commerce variables): Migrate directly. Map Gorgias customer variables to Zendesk placeholders: {{customer.first_name}} → {{ticket.requester.first_name}}, {{ticket.id}} → {{ticket.id}}. (support.zendesk.com)

• Type B — Macros with e-commerce variables ({{last_order.name}}, {{last_order.tracking_url}}): These break. Options: (1) rewrite as static text with a note for agents to paste order data from the sidebar, (2) build a custom integration via Shopify webhooks that populates Zendesk custom ticket fields with order data, then reference those fields as macro placeholders, or (3) use a third-party app like agnoStack that supports custom dynamic content. Note: some field types do not support placeholders in macros, and macros can only update ticket fields that are present on the form.

• Type C — Macros with actions (set tag, assign group, change status): Map to Zendesk macro actions. Zendesk macros typically support more action types than Gorgias. (support.zendesk.com)

For Gorgias rules, classify each as event-driven or time-driven:

• Event-driven rules (ticket created, customer replied, tag added) → Zendesk Triggers. (support.zendesk.com)
• Time-driven rules (auto-close after N days without response) → Zendesk Automations (run hourly, check time conditions).
• Autoresponder rules (auto-reply to WISMO tickets with tracking info) → Requires assembling Zendesk Intelligent Triage (detect intent, available on Suite Professional+ at $115/agent/month) + Triggers (auto-respond based on intent field) + AI Agents (for fully automated resolution). More powerful but significantly more configuration. Note: Intelligent Triage only applies to new tickets after enablement — it does not backfill historical imports. Setup requires defining intent labels, training with sample tickets, and configuring trigger conditions for each intent-action pair.

Most Gorgias teams have 10–30 rules. The rule audit and Zendesk trigger/automation build typically takes 3–7 days. Autoresponder redesign adds 3–5 days if Intelligent Triage setup is needed.

For a deeper look at the hidden complexity here, see Your Help Desk Data Migration's Secret Saboteur: Automations, Macros, and Workflows.

Migration Methods: API vs. CSV vs. Managed Service

There are five viable approaches. The right one depends on volume, history requirements, and engineering bandwidth.

a) Gorgias CSV Export + Zendesk CSV Import — Complexity: Low. Gorgias provides CSV exports via Settings → Export. Zendesk's CSV import handles users and organizations (up to 2,000 rows per file) but not tickets. Gorgias's message-content exports are limited and do not cover full threaded history with private notes. Use this for customer/contact-only imports or auditing, not for full-fidelity migration. (docs.gorgias.com)

b) API-Based Migration (Gorgias REST API → Zendesk Ticket Import API) — Complexity: Medium. Cost: Engineering time only (no licensing fees for API access). The recommended path for full-history migration. Extract tickets via GET /api/tickets (cursor-based pagination), messages via the Gorgias messages endpoint, and customers via GET /api/customers. Load into Zendesk using POST /api/v2/imports/tickets (single) or POST /api/v2/imports/tickets/create_many (batches of up to 100). The Ticket Import API preserves created_at timestamps on both tickets and individual comments, does not trigger automations, and supports the archive_immediately parameter for closed tickets. (developer.zendesk.com)

c) Hybrid: Customers via CSV + Tickets via API — Complexity: Medium. Import customers via Zendesk's bulk CSV import (handles dedup by email), then import tickets with full message history via the Ticket Import API. Pragmatic middle ground for mid-size migrations.

d) Third-Party Migration Tool — Complexity: Low. Cost: Typically $1–$3 per 100 records for tools like Help Desk Migration; Import2 uses a flat-rate model. These tools provide a mapping UI for moving tickets between platforms. Good for teams with limited engineering bandwidth and straightforward data. Less control over transformation logic and edge-case handling (e.g., custom field type coercion, inline image re-hosting). These tools move records but do not remove the Shopify workflow audit or macro rewrite work. (help-desk-migration.com)

e) Managed Migration Service — Complexity: Low (for your team). Cost: Typically $3,000–$15,000+ depending on ticket volume, macro complexity, and integration scope. A provider handles extraction, mapping, transformation, loading, and advises on the Shopify integration gap and macro rewrite. Best for >50K tickets, complex macro libraries, or tight timelines.

For most mid-market teams (20–50 agents, 100K+ tickets), an API-based migration or a managed service is the only viable route to preserve historical context.

Migration Architecture: Gorgias → Transform → Zendesk

The safest architecture is Gorgias extract → transform layer → Zendesk import. Keep transformation explicit so status mapping, tag cleanup, user dedup, and attachment handling are testable before load.

Gorgias extraction is the bottleneck. Gorgias API rate limits are plan-tiered: 2 req/s on Starter and Basic, 10 req/s on Pro and Advanced, with custom limits on Enterprise. (developers.gorgias.com) Gorgias list endpoints use cursor pagination and support up to 100 items per page. Note: the per-ticket messages endpoint may be marked deprecated in the Gorgias API reference — verify the supported extraction path before building your pipeline.

Fetching 100K tickets with ~8 messages each at 2 req/s takes approximately 5–6 days of continuous extraction. Build a per-second rate limiter; do not just retry on 429s. Request a temporary rate limit increase from Gorgias support if your plan allows it. Plan the extraction phase to run 2–3x longer than the Zendesk load phase.

Zendesk ingestion is fast. The Ticket Import API handles 400 req/min on Suite Professional and 700 req/min on Suite Enterprise. At 400 req/min using the batch endpoint (100 tickets per request), Zendesk can ingest 40,000 tickets per minute. Zendesk will ingest the transformed data much faster than Gorgias can serve it.

In the transformation layer:

• Map Gorgias ticket channels to Zendesk via fields
• Coerce custom field types (e.g., Gorgias text field containing "true"/"false" → Zendesk checkbox field)
• Normalize tags to lowercase with underscores
• Decide whether Gorgias auto-generated system messages (e.g., "Ticket merged") should be imported as Zendesk internal notes or discarded to reduce noise
• Tag imported tickets (e.g., imported_from_gorgias) and keep them out of live SLA/reporting logic — Zendesk does not import historical first reply or first resolution metrics (support.zendesk.com)
• Build an idempotency layer: store the mapping of Gorgias ticket ID → Zendesk ticket ID so the import can be resumed or re-run without creating duplicates

Here is a sample Zendesk Ticket Import API payload:

{
  "ticket": {
    "subject": "Order 10451 arrived damaged",
    "requester_id": 123456789,
    "created_at": "2025-02-14T13:07:22Z",
    "status": "closed",
    "tags": ["shopify", "damaged_item", "imported_from_gorgias"],
    "comments": [
      {
        "author_id": 123456789,
        "created_at": "2025-02-14T13:07:22Z",
        "public": true,
        "html_body": "<p>My mug arrived broken.</p>"
      },
      {
        "author_id": 987654321,
        "created_at": "2025-02-14T13:15:02Z",
        "public": false,
        "value": "Customer attached photo. Replacement approved.",
        "uploads": ["<upload_token>"]
      }
    ]
  }
}

Imported tickets do not fire triggers. Attachments are added by uploading the file first via the Uploads API and passing the returned token in the comment's uploads array. (developer.zendesk.com)

Rollback Plan: What If the Migration Fails Validation

Define rollback criteria before starting the import. A rollback plan is not optional — it is the difference between a bad week and a bad quarter.

Pre-migration safeguards:

• Export a full backup of your Gorgias data (tickets, customers, macros, rules) before starting any migration work.
• Run the migration first in a Zendesk sandbox (available on Suite Professional+ or by request from Zendesk sales). A sandbox is a separate Zendesk instance with its own subdomain that mirrors your production configuration. Use it for the test migration, UAT, and macro validation. Do not test in production.
• Keep Gorgias active and receiving tickets until go-live is confirmed.

Rollback triggers:

• Record count discrepancy >1% between Gorgias source and Zendesk target
• Timestamp corruption on >0.5% of imported tickets
• Broken author attribution (agent messages appearing as customer messages or vice versa)
• Shopify app sidebar failing to load order data for >5% of test tickets
• Agent UAT reveals workflow blockers that cannot be resolved within the go-live window

Rollback procedure:

1. Revert email/chat/social channel routing back to Gorgias.
2. Delete the failed import batch from Zendesk (bulk delete via API or contact Zendesk support for mass deletion).
3. Diagnose the root cause in the transformation layer.
4. Re-run the import in the sandbox, validate, then retry production.

Keep Gorgias in read-only mode for 8–12 weeks after go-live as a fallback reference archive. Critical: verify Gorgias's data retention policy for your plan before cancellation. Gorgias does not publicly guarantee data access after subscription ends — confirm in writing with Gorgias support how long your data remains accessible and downloadable after cancellation or downgrade.

Step-by-Step Migration Process and Timeline

[For PMs] Here is a realistic phased timeline for a mid-size team (20 agents, 100K tickets):

1. Discovery and planning (1–2 weeks). Audit Gorgias data: ticket count, macro inventory with e-commerce variable classification (count Type A/B/C macros explicitly), rule inventory, active integrations, FAQ article count. Run the Shopify app evaluation. Define custom field mapping. Confirm target Zendesk Suite plan (Suite Professional at $115/agent/month or Suite Enterprise at $169/agent/month — pricing as of early 2025, verify current rates).

2. Zendesk instance setup (1–2 weeks, parallel). Create custom fields with all dropdown values, groups, agent accounts. Connect email/chat/social channels. Install and configure the Zendesk Shopify app. Set up a Zendesk sandbox for test migration.

3. Macro rewrite + Rule rebuild (3–7 days each, parallel). Classify and rewrite macros using the Type A/B/C framework. Build triggers and automations in Zendesk. Test in sandbox.

4. Customer/end-user migration (1–3 days). End-users must exist in Zendesk before importing tickets — the Ticket Import API requires a valid requester_id. Dedup by email address.

5. Test migration in sandbox (2–3 days). Import a representative sample (1,000–5,000 tickets covering all status types, channels, and custom field values) into the Zendesk sandbox. Run full validation. Fix transformation issues. Re-run until clean.

6. Ticket history migration to production (3–7 days). Gorgias extraction is the bottleneck due to API rate limits. Download all attachments and inline images during extraction — Gorgias-hosted URLs may expire post-migration — and re-upload via Zendesk's Uploads API.

7. FAQ → Zendesk Guide migration (1–3 days). Gorgias provides a basic, flat FAQ structure. Zendesk Guide uses a strict Category → Section → Article hierarchy. If your FAQ has fewer than 30 articles, manual copy-paste is faster than scripting. For larger sets, use the Zendesk Help Center API (POST /api/v2/help_center/sections/{id}/articles). Extract the HTML from Gorgias, re-upload inline images to Zendesk, and rewrite the image URLs in the HTML body. Set up 301 redirects from old Gorgias FAQ URLs to new Zendesk Guide URLs before launch. (support.zendesk.com)

8. Validation and UAT (1 week). Record-count reconciliation, timestamp verification, author attribution spot checks, attachment verification, macro testing, Shopify app validation. Have 2–3 agents work in Zendesk for 1–2 days focusing on the Shopify app sidebar workflow, macro usability (especially rewritten Type B macros), and the Pending/Solved status lifecycle.

9. Agent training (2–3 days, parallel with UAT). Train all agents on: the five-status ticket lifecycle (New/Open/Pending/Solved/Closed), the Shopify sidebar workflow (where to find order data, how to issue refunds), rewritten macros (which ones changed and why), and Zendesk-specific features they gain (SLAs, views, Explore dashboards). Create a one-page cheat sheet mapping Gorgias workflows to Zendesk equivalents.

10. Go-live and monitoring (1 week). Cut over email/chat/social channels. Monitor handling time, CSAT, and ticket backlog daily. Keep Gorgias in read-only mode for 8–12 weeks as a fallback reference archive.

Critical order-of-operations: Custom fields with dropdown values → end-users → tickets with comments → attachments → tags. Violating this sequence causes import failures.

The highest risk to your timeline is the macro rewrite. Count and classify all macros in week one to avoid surprises.

What Can't Be Migrated from Gorgias to Zendesk

Be honest with stakeholders about what does not transfer:

• Revenue statistics → No native Zendesk equivalent. Export and archive from Gorgias before migration. Replace with Shopify analytics plus Zendesk Explore custom reports.
• Macro e-commerce variables → Zendesk macros cannot natively pull Shopify data. Must be rewritten (Type B macros).
• Native Shopify order editing → Replaced by marketplace apps with varying depth. Verify capabilities before go-live.
• Rules → Must be rebuilt as Triggers and Automations. Straightforward but manual.
• Intent/sentiment detection model → Gorgias's AI model does not transfer. Zendesk Intelligent Triage uses its own taxonomy (trained on Zendesk's cross-customer dataset, not your Gorgias data). Historical tags are preserved as data but do not train Zendesk's model.
• Proactive chat campaigns with e-commerce triggers → Must be rebuilt in Zendesk Messaging. E-commerce-specific triggers (cart value, checkout page) require custom implementation via JavaScript conditions or a third-party tool.
• Gorgias Convert → No Zendesk equivalent. If this drives measurable revenue, evaluate standalone conversion tools (Justuno, Privy) before go-live.
• CSAT historical data → Can be stored as custom field values but will not appear in Zendesk's native CSAT reporting. Export CSAT trends from Gorgias before cancellation.
• Views and analytics dashboards → Must be recreated manually in Zendesk Views and Explore.
• Historical first reply and first resolution metrics → Imported tickets do not carry these performance metrics into Zendesk. Expect a metrics "reset" — communicate this to leadership before go-live to avoid alarming reports. (support.zendesk.com)

Edge Cases and Known Challenges

• Inline images expire. Gorgias inline images use hosted URLs that may expire after you leave the platform. Download all attachments and inline images during extraction and push them through the Zendesk Uploads API. Do not assume Gorgias image URLs will remain accessible. Verify by checking image URLs from tickets older than 12 months before starting extraction.

• Duplicate customers. Zendesk requires unique email addresses for end-users. Deduplicate Gorgias customers before import and define merge rules for conflicting data (e.g., two Gorgias customer records with the same email but different phone numbers — pick the most recently updated record).

• Very long tickets. Zendesk caps tickets at 5,000 comments. If any Gorgias ticket has an exceptionally long thread, it must be split or truncated before import. (developer.zendesk.com)

• Old email thread behavior. Customers replying to old Gorgias email threads may create new Zendesk tickets rather than reopening the imported ticket, depending on how email headers transfer. Test this behavior in the sandbox before go-live — the preserved ticket history is documented; legacy email-thread behavior is not.

• Social channels must be reconnected. Historical Gorgias social tickets can be imported as records, but live social messaging channels (Facebook, Instagram, Twitter/X) must be set up separately in Zendesk. This is a separate configuration task, not part of the data migration. (support.zendesk.com)

• Gorgias API deprecations. The per-ticket messages endpoint may be marked deprecated in the Gorgias API reference. Verify the supported extraction path before building your pipeline. (developers.gorgias.com)

• Ticket snooze mapping. Gorgias has a snooze function. If a ticket's snooze wake time is in the future, map it to Zendesk "Pending" and create an automation to reopen it based on a custom date field storing the original wake time.

• API rate limits on extraction. Extracting 100K+ tickets at 2 req/s (Starter/Basic plans) requires approximately 5–6 days of continuous extraction. Plan extraction as a multi-day background job. Request a temporary rate limit increase from Gorgias support if available on your plan.

• Multi-store Shopify configurations. If your Gorgias instance connects to multiple Shopify stores, each store must be configured separately in Zendesk's Shopify app. Customer dedup becomes more complex because the same customer may have different Shopify customer IDs across stores. Map customer records by email, not by Shopify ID.

• Gorgias data retention post-cancellation. Gorgias does not publicly document how long data remains accessible after subscription cancellation. Confirm retention terms in writing with Gorgias support before starting migration. Complete your full data extraction before downgrading or canceling your Gorgias plan.

Validation and Testing After Migration

Run strict QA before turning off Gorgias.

Record counts. Verify ticket, user, and tag counts between Gorgias exports and Zendesk UI. Acceptable variance: <0.5% (typically caused by dedup or tickets filtered by the transformation layer).

Timestamp integrity. Imported tickets must show original Gorgias creation dates, not the date of the migration. Spot-check 50+ tickets across different date ranges.

Author attribution. Spot-check that customer messages appear as public comments from the correct end-user, agent replies appear as public comments from the correct agent, and internal notes remain private. Check at least 20 tickets with mixed agent/customer/internal note threads.

Attachments. Verify that inline images render and file attachments download correctly. Check for broken image URLs from expired Gorgias hosting. Test at least 10 tickets with attachments.

Custom fields and tags. Spot-check custom field values, dropdown mappings, and tag normalization results. Verify that no tags contain spaces or uppercase characters.

Shopify app validation. Open 10+ imported tickets in Zendesk and verify the Shopify sidebar loads the correct customer and order data. Test a refund workflow end-to-end in the sandbox.

Agent UAT. Have 2–3 agents run UAT for 1–2 days. Focus on the Shopify app sidebar workflow, macro usability (especially rewritten Type B macros), and the Pending/Solved status lifecycle. Document all friction points and resolve blockers before go-live.

For a complete testing framework, read Post-Migration QA: 20 Tests to Run After Your Help Desk Data Migration.

What Do Agents and Customers Notice After Migration?

[For customer success] Customers typically see no downtime on email if channels are cut over at go-live. Chat customers will see the new Zendesk Messaging widget instead of the Gorgias widget — the visual design, position, and greeting message will differ, so update your widget styling to match your brand before go-live.

Agents notice three things immediately: the Shopify sidebar replaces the embedded order panel, macros that used to auto-populate order data now require manual copy-paste (unless you built the custom field integration), and the ticket lifecycle changes from Open/Closed to New/Open/Pending/Solved/Closed.

Proactive chat campaigns triggered by Shopify cart value do not migrate. Rebuild priority campaigns in Zendesk Messaging before go-live to avoid conversion drops.

Because the Ticket Import API preserves original timestamps and threading, agents retain full historical context. But note: Zendesk does not import historical first reply or first resolution metrics, so those benchmarks reset. Communicate this reset to leadership before go-live to prevent misinterpretation of post-migration Explore dashboards.

Should You Migrate In-House or Use a Service?

In-house works when: fewer than 10K tickets, few macros with e-commerce variables, minimal reliance on in-ticket Shopify actions, available engineering time (estimate 40–80 hours for a developer experienced with REST APIs), and the team accepts a Shopify app sidebar workflow.

In-house does not work when: large ticket history (>50K tickets), extensive e-commerce macro library (30%+ using Shopify variables), heavy reliance on in-ticket refund/cancel/edit, autoresponders with intent-based auto-replies, tight timeline (<3 weeks), or the engineering team is allocated to other priorities.

The hidden cost of DIY is the workflow redesign, not the data migration. The Zendesk Ticket Import API is the cleanest import path in the helpdesk space. But the macro rewrite, Shopify integration evaluation, and agent change management are unique to Gorgias migrations and have no parallel in generic helpdesk-to-helpdesk moves.

The market reflects this split clearly: tools like Help Desk Migration (per-record pricing, UI-based mapping, handles 30+ platform pairs) and Import2 (flat-rate, focused on smaller migrations) handle fast automated record transfer, while the real decision line is whether you also need help with the e-commerce workflow replacement. Record transport and e-commerce workflow parity are different workstreams.

ClonePartner has completed 1,500+ data migrations across helpdesk, CRM, and ITSM platforms. For Gorgias-to-Zendesk specifically, we handle full ticket history migration via the Ticket Import API (message threading, attachments, timestamp preservation), customer and tag migration with normalization, custom field creation and type matching, knowledge base migration to Zendesk Guide, and advisory on the Shopify integration evaluation and macro rewrite strategy.