Helpdesk migration
Field-level mapping, validation, and rollback between Pylon and Gorgias. We move data and schema; workflows are rebuilt natively in Gorgias.
Pylon
Source
Gorgias
Destination
Compatibility
9 of 13
objects map 1:1 between Pylon and Gorgias.
Complexity
CModerate
Timeline
3-5 weeks
Overview
Moving from Pylon to Gorgias is a platform-model migration, not a record copy. Pylon organizes support around Issues with full conversation threads in Slack, Teams, and email channels, storing customer context in an Account Intelligence layer with Notebooks, Tasks, and Activities. Gorgias is ticket-centric with a flat customer table, Shopify order context surfaced via sidebar integration, and Rules-and-Macros automation instead of Pylon's workflow engine. We handle the structural differences: flattening Pylon's nested account-contact hierarchy into Gorgias's flat customer model, mapping Pylon channel assignments to Gorgias channel types, resolving custom fields against Gorgias's type system, and surfacing Pylon's Account Intelligence data as customer-level notes or properties. Macros, Rules, and automation configurations do not migrate; we deliver a written inventory for the customer's admin to rebuild. Integration configuration (webhooks, connected apps) also does not migrate and is documented separately for reconfiguration after cutover.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a Pylon object lands in Gorgias, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
Pylon
Issue
Gorgias
Ticket
1:1Pylon Issues map to Gorgias Tickets. We preserve external comments as Ticket messages (channel determined by Issue channel assignment: email, chat, Facebook, Instagram, WhatsApp, SMS), and Pylon internal notes migrate to Gorgias's internal note field. Created time, first response time, and resolution time transfer as metadata. The Issue ID is stored in a custom field pylon_issue_id__c for audit traceability. Priority and status map from Pylon Issue priority and state to Gorgias ticket priority and status. Note: Pylon's thread-based model means a single Issue may contain multiple channel conversations — we collapse these into a single ticket with multi-channel message history.
Pylon
Account
Gorgias
Customer
1:1Pylon Accounts (organizations) map directly to Gorgias Customers. The Account's domain, industry, and custom fields transfer as Customer properties. Pylon Account Intelligence data (health scores, risk flags, account tier) migrates as custom properties on the Customer record if Gorgias supports equivalent custom fields, or as structured notes if no custom field equivalent exists. Customer is created before any related Issue migration so the customer-ticket relationship is satisfied at import time.
Pylon
Contact
Gorgias
Customer (same table)
1:manyPylon Contacts attached to an Account merge into the corresponding Gorgias Customer record. Pylon's per-contact email, phone, language, and timezone become properties on the Gorgias Customer. When multiple Pylon Contacts share an Account, their data is consolidated into one Gorgias Customer. The original Pylon contact_id is stored in a custom field pylon_contact_id__c for reconciliation. If the customer uses a flat contact model in Pylon without accounts, each Contact maps 1:1 to a Gorgias Customer.
Pylon
Team
Gorgias
Team
1:1Pylon Teams map to Gorgias Teams. Team membership (agents assigned to each team) migrates as team assignments in Gorgias. Where Pylon routing rules are encoded as team-based conditions rather than static assignments, we represent those rules as a written routing matrix for the customer's admin to implement in Gorgias Rules.
Pylon
User (Agent)
Gorgias
Agent
1:1Pylon Users map to Gorgias Agents by email match. Agent profiles (name, email, role, availability settings) transfer directly. We resolve each Pylon User against the Gorgias agent table by email; any Pylon User without a matching Gorgias Agent is placed in a reconciliation queue for the customer's admin to provision before migration resumes. Agent-level metrics (CSAT, handle time) stored as custom fields in Pylon do not have a direct Gorgias equivalent and are preserved as custom fields on the Agent record.
Pylon
Custom Fields (Issues)
Gorgias
Custom Fields (Tickets)
lossyPylon Issue custom fields (text, number, decimal, select, multi-select, boolean, date, datetime, URL) map to Gorgias ticket custom fields. Select and multi-select fields require pre-creation of the picklist values in Gorgias before migration. Boolean fields map to Gorgias checkboxes. Number and decimal fields map to Gorgias number fields with type preservation. We generate a schema diff listing each Pylon custom field, its data type, and the required Gorgias field type and configuration before migration begins.
Pylon
Custom Fields (Accounts)
Gorgias
Custom Fields (Customers)
lossyPylon Account custom fields (account tier, health score, risk flag, or any custom account property) map to Gorgias customer custom fields. Same type-mapping rules apply as for Issue custom fields. Pylon's Account Intelligence custom fields are included in this mapping scope. We generate a separate schema diff for account-level fields distinct from the ticket-level field diff.
Pylon
Custom Fields (Contacts)
Gorgias
Custom Fields (Customers)
lossyPylon Contact custom fields migrate to Gorgias customer custom fields following the same type-mapping pipeline as Account and Issue custom fields. Fields that exist at both the Account and Contact level in Pylon are merged into single customer fields in Gorgias, with a note in the schema diff documenting the source record type for each field value.
Pylon
Article
Gorgias
Help Center Article
1:1Pylon Knowledge Base Articles migrate to Gorgias Help Center articles. Article content (text, rich text, embedded media) transfers with HTML sanitization applied. Author and last-modified timestamp are preserved as article metadata. Published status migrates — articles in draft state in Pylon remain draft in Gorgias. Article-to-Collection assignments are preserved through a separate mapping table during migration.
Pylon
Collection
Gorgias
Category
1:1Pylon Collections (folders) map to Gorgias Help Center categories. Nested sub-collections in Pylon map to sub-categories in Gorgias. Permission settings on Collections are documented as access-control notes for the customer's admin to configure in Gorgias Help Center settings. The article-to-collection assignment is preserved through the mapping table generated during the Article migration phase.
Pylon
Account Intelligence: Notebook
Gorgias
Customer Note
1:1Pylon Notebooks (structured account health notes, summaries, and context documents) migrate to Gorgias customer notes attached to the corresponding Customer record. Each Notebook's content, author, and timestamp transfer as a dated note entry on the Customer. If the customer has a high volume of Notebooks, we batch them by Account to minimize the number of individual note inserts.
Pylon
Account Intelligence: Task
Gorgias
Customer Note
1:1Pylon Tasks and Projects from the Account Intelligence layer migrate as dated note entries on the corresponding Gorgias Customer. The task title, description, due date, and completion status transfer as note content formatted in a structured template (e.g., '[Task] Due: YYYY-MM-DD — description'). If Gorgias has a task or to-do feature available on the customer's plan, we document it as a configuration recommendation rather than forcing the note-format migration.
Pylon
Account Intelligence: Activity
Gorgias
Customer Note
1:1Pylon Activities (login events, feature usage, support interactions tracked as account-level events) migrate as dated note entries on the Gorgias Customer record in reverse chronological order. High-frequency activity logs are summarized or sampled at migration time to avoid note inflation; the original activity log is documented as a CSV export excluded from the migration target.
| Pylon | Gorgias | Compatibility | |
|---|---|---|---|
| Issue | Ticket1:1 | Fully supported | |
| Account | Customer1:1 | Fully supported | |
| Contact | Customer (same table)1:many | Fully supported | |
| Team | Team1:1 | Fully supported | |
| User (Agent) | Agent1:1 | Fully supported | |
| Custom Fields (Issues) | Custom Fields (Tickets)lossy | Fully supported | |
| Custom Fields (Accounts) | Custom Fields (Customers)lossy | Fully supported | |
| Custom Fields (Contacts) | Custom Fields (Customers)lossy | Fully supported | |
| Article | Help Center Article1:1 | Fully supported | |
| Collection | Category1:1 | Fully supported | |
| Account Intelligence: Notebook | Customer Note1:1 | Fully supported | |
| Account Intelligence: Task | Customer Note1:1 | Fully supported | |
| Account Intelligence: Activity | Customer Note1:1 | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
Pylon gotchas
AI pricing is a separate billing line item
Annual billing with seat minimums locks migration timing
Seamless email migration only works from Zendesk, Front, or Intercom
Pylon migrates data only, not destination configuration
Learning curve delays agent productivity post-migration
Gorgias gotchas
AI Agent adds outcome-based fees on top of billable ticket costs
Overage billing for tickets scales nonlinearly
API rate limits restrict bulk export throughput
Agent data visibility cannot be restricted by role for GDPR use cases
Knowledge Base translations require separate API calls per locale
Pair-specific challenges
Migration approach
Discovery and migration strategy session
We audit the source Pylon workspace across all objects: Issue volume (open and closed), Account count, Contact count, Team structure, User roster, custom field schemas on Issues, Accounts, and Contacts, Knowledge Base article count and collection structure, and Account Intelligence object volume. We pair this with a Gorgias plan recommendation based on estimated monthly ticket volume. We conduct a strategy session to decide whether Pylon's multi-channel threads collapse into single Gorgias tickets or split by channel, and to identify which Account Intelligence objects the customer wants migrated versus documented for manual re-entry. The discovery output is a written migration scope document.
Schema diff and field mapping design
We generate a complete schema diff comparing every Pylon custom field (by name, data type, and object) against Gorgias's supported field types. Select and multi-select fields require pre-creation of picklist values in Gorgias before migration; we deliver the exact values list for each field. Number, decimal, boolean, date, and text fields map directly where equivalent types exist. For Account Intelligence fields with no Gorgias equivalent, we define the target (custom customer property, structured note, or excluded) and document it in the diff. This diff is reviewed by the customer's admin before any schema creation begins.
Pylon data extraction via API
We extract data from Pylon using the Pylon REST API with rate-limit handling and exponential backoff. The extraction runs in phases: Users and Teams first (for agent matching), then Accounts and Contacts (for parent-record resolution), then Issues with full thread history (external comments, internal notes, channel metadata), then Knowledge Base Articles and Collections, then Account Intelligence objects (Notebooks, Tasks, Projects, Activities). Each extraction phase emits a record count and data quality report. Inline images embedded in Pylon thread messages are extracted separately as attachment references and re-hosted in Gorgias during insertion.
Gorgias schema provisioning and test migration
We pre-create all required custom fields in Gorgias (ticket custom fields, customer custom fields) using the exact names and data types from the schema diff. We configure Teams in Gorgias to match the Pylon Team structure. We run a test migration into a Gorgias trial or staging account with a representative sample of records (10% of total volume) and perform reconciliation: record counts per object, spot-check of 20-30 random tickets for message completeness and internal note attribution, and custom field value verification. Corrections to the mapping logic are applied before the full migration begins.
Full production migration
We run the production migration in dependency order: Agents (resolved by email match, held in reconciliation queue if missing), Customers (from Pylon Accounts, with Account Intelligence data attached), Knowledge Base Categories and Articles (for article-to-category assignment mapping), then Tickets (with thread history collapsed or split per the agreed strategy, and Customer lookup resolved at insert time). Each phase emits a row-count reconciliation report. We apply tagging to migrated tickets (pylon_imported: true, pylon_issue_id: original ID) for future reference. A final delta pass captures any Pylon records created or modified during the migration window.
Cutover, validation, and automation rebuild handoff
We freeze Pylon write access at cutover, run the final delta migration, then mark Gorgias as the system of record. We deliver the Migration Summary Report covering record counts per object, data quality metrics, unmapped fields (if any), and the Pylon integration inventory. We deliver the Workflow and Rule inventory document: every Pylon Workflow trigger, condition, and action is documented with a recommended Gorgias Rule or Macro equivalent. We do not rebuild Pylon Workflows as Gorgias Rules inside the migration scope. Integration reconfiguration (webhooks, connected apps) is documented in a separate checklist for the customer's admin. We offer a one-week hypercare window for reconciliation issues raised by the support team during live operation.
Platform deep dives
Pylon
Source
Strengths
Weaknesses
Gorgias
Destination
Strengths
Weaknesses
Complexity grading
Moderate Helpdesk migration. 3 of 7 objects need a mapping; the rest are 1:1.
Overall complexity
Moderate migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Pylon and Gorgias.
Object compatibility
3 of 7 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
7-object category — typical timelines run 2–7 days end-to-end.
API constraints
Pylon: Not publicly documented.
Data volume sensitivity
Pylon doesn't expose a bulk API — REST + parallelization used for high-volume runs.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during Pylon to Gorgias migration scoping. Not seeing yours? Book a call.
Walk through your Pylon to Gorgias migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave Pylon
Other ways to arrive at Gorgias
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.