Helpdesk migration
Field-level mapping, validation, and rollback between OpenText Service Request Center (SRC) and Gorgias. We move data and schema; workflows are rebuilt natively in Gorgias.
OpenText Service Request Center (SRC)
Source
Gorgias
Destination
Compatibility
10 of 13
objects map 1:1 between OpenText Service Request Center (SRC) and Gorgias.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from OpenText Service Request Center to Gorgias is a platform-category shift, not a direct replacement. SRC is an enterprise ITSM product built for IT departments managing complex service catalogs, multi-tier SLA hierarchies, and compliance-grade audit trails across regulated industries. Gorgias is an eCommerce-native helpdesk built for Shopify stores handling order-related support, with deep order-context integration and automation designed for DTC brands. The migration collapses a structured ITSM model into a flatter ticket model: Service Requests and Incidents merge into Gorgias Tickets, KB Articles map to Gorgias Articles, and complex SLA calendars simplify to Gorgias rule-based SLA targets. We do not migrate workflows, service catalogs, or SLA hierarchies as code; we deliver a written inventory of each for the customer's admin to rebuild in Gorgias Rule Engine.
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 OpenText Service Request Center (SRC) 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.
OpenText Service Request Center (SRC)
Service Request
Gorgias
Ticket
1:1SRC Service Requests map directly to Gorgias Tickets as the primary ticket object. Request type, priority, status, description, requester reference, and assignment map to Gorgias Ticket type, priority, status, body/description, customer_id, and assigned_agent. SRC Service Request custom fields (user options on offerings) map to Gorgias Ticket Fields. Service Request attachments migrate inline. The SRC request category or offering type maps to Gorgias Ticket Tags for segmentation.
OpenText Service Request Center (SRC)
Incident
Gorgias
Ticket (separate type or merged)
1:manySRC separates Incidents (IT infrastructure disruptions) from Service Requests (user-initiated service requests). Gorgias has a single Ticket model. We assess whether the customer's SRC Incidents represent a distinct operational process (separate SLA targets, separate routing) or whether they functioned as a second ticket queue for the same support team. If distinct, Incidents migrate as Tickets with a tag 'incident-source' for filtering in Gorgias. If functionally equivalent, Incidents merge into the main Ticket import with other metadata preserved in custom fields.
OpenText Service Request Center (SRC)
Knowledge Base Article
Gorgias
Article
1:1SRC KB Articles storing resolution content linked to tickets map to Gorgias Articles. Article title, body, and category migrate. SRC articles frequently contain HTML formatting with embedded images, tables, and links that require sanitization during migration. We apply an HTML-to-markdown conversion preserving as much structure as possible, re-host inline images to a temporary storage endpoint, and flag articles with tables or complex formatting for manual review. Article-to-ticket associations are preserved as Ticket Tags or linked notes in Gorgias. SRC article metadata (author, created date, last modified) migrates to Gorgias Article metadata fields.
OpenText Service Request Center (SRC)
User (Internal Agent)
Gorgias
Agent
1:1SRC internal users (agents, support staff) map to Gorgias Agents. Display name, email address, department, and role migrate. SRC role definitions (admin, agent, viewer) map to Gorgias Agent permission levels. SRC group memberships map to Gorgias Team membership. SRC manager hierarchies for reporting do not have a direct Gorgias equivalent; we preserve the hierarchy in a custom field for reporting purposes. Agent status (active/inactive) migrates; inactive agents are provisioned in Gorgias as deactivated to preserve ticket history.
OpenText Service Request Center (SRC)
Customer (External Requester)
Gorgias
Customer
1:1SRC external requesters tracked as Customer records (distinct from internal Users) map to Gorgias Customers. Customer name, email, phone, company, and address fields migrate directly. Customer notes and any custom customer fields migrate to Gorgias Customer fields. SRC customer-to-ticket association links migrate as Gorgias Ticket-to-Customer relationships via customer_id lookup. If the destination Gorgias account has Shopify or Magento integration enabled, we validate customer email addresses against the eCommerce platform to link existing customer profiles rather than creating duplicate records.
OpenText Service Request Center (SRC)
Attachment
Gorgias
Attachment
1:1Files attached to Service Requests, Incidents, and KB Articles migrate as Gorgias Ticket Attachments and Article Attachments. SRC attachments stored inline with the ticket record migrate directly. SRC attachments stored in external systems (including OpenText Content Suite repositories) require explicit resolution: we retrieve files from the external repository during discovery, re-host them to a temporary accessible endpoint, and import them inline with the parent ticket. External Content Suite attachment references that cannot be resolved are documented as broken links for manual remediation by the customer's admin. File size limits (Gorgias caps attachments at 25MB per file) require chunking for larger files.
OpenText Service Request Center (SRC)
SLA Definition
Gorgias
SLA Rule
lossySRC SLA configurations define response and resolution targets tied to priority levels, service categories, and calendar definitions. Gorgias SLA Rules use a simpler timer model: a defined period (in hours or business hours) from ticket creation or last customer reply, with calendar association per SLA rule. We export SRC SLA definitions during discovery, map priority levels to Gorgias priority (low, medium, high, urgent), and configure Gorgias SLA Rules for each priority. SRC calendar definitions (business hours per service category) require conversion to Gorgias Business Hours settings, which support a single active business hours schedule per account unless using multi-channel rules. Complex multi-calendar SRC configurations that assign different business hours per service category are simplified to a primary business hours schedule with the note that service-category-specific SLAs require Gorgias rule-engine workaround or manual timer tracking.
OpenText Service Request Center (SRC)
Team and Support Group
Gorgias
Team
1:1SRC support groups defining ticket routing and agent ownership map to Gorgias Teams. Group name, email routing alias, and group membership (list of agent user_ids) migrate to Gorgias Team with members assigned. SRC team-level SLA assignments map to Gorgias Team SLA Rules where applicable. If SRC uses nested groups (sub-groups within parent groups), the hierarchy is flattened to Gorgias Teams with the parent relationship noted in a custom field for reporting. Email routing aliases from SRC are preserved in Gorgias inbox routing rules.
OpenText Service Request Center (SRC)
Custom Field (Service Request / Incident)
Gorgias
Ticket Field
1:1SRC custom fields (user options) on Service Requests and Incidents accumulate across years of deployment and vary significantly between SRC instances. We audit all custom field configurations during discovery: field name, data type (text, number, boolean, date, picklist, multi-select), validation rules, and picklist values. These map to Gorgias Ticket Fields of equivalent type (text fields, number fields, boolean toggles, single-select and multi-select dropdowns). SRC picklist values map to Gorgias Ticket Field options. Custom field validation rules (required, conditional required, format) are noted for manual recreation in Gorgias Field Settings. Fields without a Gorgias equivalent (e.g., SRC-specific data types) are flagged as unsupported and preserved in a custom JSON field on the Ticket for future extraction.
OpenText Service Request Center (SRC)
Service Catalog Item / Offering
Gorgias
(not migrated)
1:1SRC service catalog items and request offerings are defined within the catalog module and are not portable in structured format. Gorgias does not have a service catalog equivalent; it organizes help content through Articles and Categories. We extract catalog item metadata (name, description, category, associated SLA, associated custom fields) during discovery and deliver a written catalog reconstruction guide. The customer's admin uses this guide to create Articles representing the former catalog offerings and sets up Gorgias Category structure to mirror the SRC catalog hierarchy. Service catalog associations on migrated tickets are preserved as Ticket Tags.
OpenText Service Request Center (SRC)
Workflow Definition
Gorgias
(not migrated)
1:1SRC workflow definitions are tightly coupled to the platform's internal process engine and are not exportable in a portable format. This includes approval chains, escalation rules, automatic assignment rules, and notification triggers. Gorgias uses a Rule Engine with triggers (new ticket, customer reply, agent reply, status change) and actions (assign, tag, macro apply, SLA pause). We document every active SRC workflow with its trigger, conditions, actions, and escalation path, and deliver a written Workflow Inventory that maps each SRC workflow to a Gorgias Rule equivalent. The customer's admin rebuilds workflows using Gorgias Rule Engine or macros post-migration.
OpenText Service Request Center (SRC)
Audit Log / History
Gorgias
(partial migration)
lossySRC maintains comprehensive audit trails and compliance logs for enterprise IT governance. Gorgias stores ticket edit history (edits on the ticket, assignments, status changes) as Ticket Events. We migrate the most recent 12 months of ticket edit history as Gorgias Ticket Events (up to 500 events per ticket as allowed by Gorgias API). Older history or system-level audit entries are not migratable. If the customer requires full compliance audit retention, we recommend a separate audit log export from SRC (available as report export) to be stored in a document repository outside Gorgias. SLA breach history and escalation records migrate as Ticket Events tagged 'sla-breach' or 'escalation' if the data is extractable from SRC.
OpenText Service Request Center (SRC)
Timestamp / Historical Data
Gorgias
Ticket Created At / Updated At
1:1SRC stores created_date, modified_date, and SLA timer values (time_to_response, time_to_resolution) on Service Requests and Incidents. These timestamps migrate to Gorgias Ticket created_at and updated_at fields. SRC SLA breach timestamps (date_time when SLA was breached) migrate as Ticket Tags or custom fields if the customer requires breach history visibility. The migration preserves the full historical timeline so that ticket aging, SLA performance, and volume trends are intact for reporting in Gorgias. We set the migrated flag on records that have been backdated to their original SRC timestamps to distinguish migrated historical data from new tickets created in Gorgias.
| OpenText Service Request Center (SRC) | Gorgias | Compatibility | |
|---|---|---|---|
| Service Request | Ticket1:1 | Fully supported | |
| Incident | Ticket (separate type or merged)1:many | Fully supported | |
| Knowledge Base Article | Article1:1 | Fully supported | |
| User (Internal Agent) | Agent1:1 | Fully supported | |
| Customer (External Requester) | Customer1:1 | Fully supported | |
| Attachment | Attachment1:1 | Fully supported | |
| SLA Definition | SLA Rulelossy | Fully supported | |
| Team and Support Group | Team1:1 | Fully supported | |
| Custom Field (Service Request / Incident) | Ticket Field1:1 | Fully supported | |
| Service Catalog Item / Offering | (not migrated)1:1 | Fully supported | |
| Workflow Definition | (not migrated)1:1 | Fully supported | |
| Audit Log / History | (partial migration)lossy | Fully supported | |
| Timestamp / Historical Data | Ticket Created At / Updated At1: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.
OpenText Service Request Center (SRC) gotchas
SLA calendar and business-hours definitions vary by deployment
Custom field data types and validation rules are not portable
Attachment storage paths may reference external repositories
Knowledge base articles may contain HTML formatting incompatible with plain-text destinations
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 source audit
We conduct a comprehensive audit of the SRC deployment: Service Request and Incident record counts, SLA definitions and calendar assignments, Knowledge Base article count and formatting, custom field inventory (name, type, picklist values, validation rules), attachment storage paths and file counts, user and agent roster with group memberships, service catalog item count and metadata, active workflow definitions, and API availability (SaaS vs. on-premises). For on-premises SRC deployments, we coordinate with the customer's IT team to establish a secure read-only database connection or export mechanism. The discovery output is a written Migration Scope document with record counts, complexity flags, and an honest assessment of what can and cannot migrate automatically.
KB article and attachment pre-processing
Before any record migration, we pre-process Knowledge Base Articles and Attachments. KB Articles are passed through an HTML sanitization pipeline that converts tables to structured text, re-hosts inline images to a temporary accessible endpoint, strips SRC internal URLs, and flags articles with unsupported formatting for manual review. Attachments are scanned for external Content Suite repository references. Retrievable files are pulled from Content Suite; inaccessible files are documented. This pre-processing step runs two to three weeks in parallel with Gorgias account configuration and prevents mid-migration data quality issues.
Gorgias account configuration
We configure the destination Gorgias account before any data import. This includes creating the Agent roster (matching SRC users to Gorgias agents with correct permission levels), configuring Teams (matching SRC support groups to Gorgias Teams with member assignments), setting up Business Hours for SLA Rules (mapping SRC primary calendar to Gorgias Business Hours), creating Ticket Fields for migrated SRC custom fields, creating Tags for SRC categories and catalog item associations, and configuring the Knowledge Base with Category hierarchy mirroring the SRC catalog structure. All configuration is validated in a Gorgias sandbox environment before production migration begins.
Customer and Agent migration
We migrate SRC Customers (external requesters) and Agents (internal users) as the foundational records before ticket migration. Customer records import first, with email addresses validated against any connected Shopify or eCommerce platform to link existing customer profiles. Agent records import second, with group memberships mapped to Gorgias Team membership. Any SRC user records without a matching email in Gorgias are held in a reconciliation queue for the customer's admin to provision before record import resumes. Agent permission levels (admin, agent, restricted) map from SRC role definitions and are validated with the customer's admin before activation.
Ticket migration in dependency order
We migrate Service Requests and Incidents as Gorgias Tickets in dependency order: tickets with no attachment dependencies first, then tickets with attachments (file uploads processed inline), then tickets with associated KB Article links. Each phase emits a row-count reconciliation report. SLA timers are calculated from SRC SLA target values and stored as Gorgias SLA Rule associations per ticket priority. Incidents are migrated with the split or merge decision applied from scoping. Ticket timestamps (created_at, updated_at) are preserved from SRC for historical accuracy. Any records that fail validation (required field missing, attachment size exceeded) are held in a retry queue and processed after the bulk migration completes.
KB article and catalog handoff migration
KB Articles migrate as Gorgias Articles in parallel with ticket migration or immediately after. Article-to-ticket associations are preserved as Ticket Tags. The Catalog Reconstruction Guide is delivered alongside the article migration report. Service catalog item metadata (catalog item name, description, category, associated custom fields) is documented in a structured format the customer's admin uses to recreate catalog items as Gorgias Articles and Categories. We do not create the Articles and Categories inside Gorgias; we deliver the structured guide and the customer's admin implements it, or it can be added as a post-migration configuration service.
Cutover, validation, and Workflow rebuild handoff
We freeze SRC write access during cutover (typically a weekend window) and run a final delta migration of any tickets modified during the migration window. Gorgias is enabled as the system of record once delta records are confirmed. We deliver the Workflow Inventory document mapping each SRC workflow to a Gorgias Rule equivalent, the Catalog Reconstruction Guide, and the SLA Mapping document showing how each SRC SLA calendar maps to Gorgias Business Hours and SLA Rules. We support a one-week hypercare window for reconciliation issues. We do not rebuild SRC workflows, service catalog items, or SLA calendars as Gorgias configurations inside the migration scope; these are separate rebuild engagements or internal admin tasks.
Platform deep dives
OpenText Service Request Center (SRC)
Source
Strengths
Weaknesses
Gorgias
Destination
Strengths
Weaknesses
Complexity grading
Standard Helpdesk migration. 4 of 7 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across OpenText Service Request Center (SRC) and Gorgias.
Object compatibility
4 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
OpenText Service Request Center (SRC): Not publicly documented numerically — Service Manager REST API enforces session-based throttling and the OpenText Integration Studio recommends batch sizes appropriate to deployment scale rather than a published per-minute limit..
Data volume sensitivity
OpenText Service Request Center (SRC) exposes a bulk API — large-volume migrations stream efficiently.
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 OpenText Service Request Center (SRC) to Gorgias migration scoping. Not seeing yours? Book a call.
Walk through your OpenText Service Request Center (SRC) 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 OpenText Service Request Center (SRC)
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.