If you are getting ready to move your support operations into Gladly, it might feel different from classic ticketing tools. It is people-centered, not ticket-centered, and that changes how you prepare, how you import, and how you set up your workspace.
After doing many migrations into Gladly, I’ve learned that the teams who slow down early, build the workspace properly and treat customers as the core object always have a smooth cutover.
This checklist walks you from scoping the migration to pre-migration setup, into the data import, and then the post-go-live validation.
Scope the migration
Before you touch any API endpoints, get clarity on your true scope. Gladly structures everything around customers, so understanding your data model ahead of time saves you from messy mapping later.
- Decide how much history matters
Choose whether you are migrating two years, five years, or full history. Long histories are fine, but you should be intentional about it because Gladly centers each conversation around a living customer record. - Understand who needs to exist in Gladly
List every agent who must appear in conversation histories. If ownership matters for legacy work, include inactive agents as well. - Choose the objects you will migrate
Customer profiles, conversations, conversation items, messages, notes, tasks, topics, and custom attributes. Consider what actually brings value to future agents. - Decide what to skip
Outdated spam, empty conversations, junk customers, bad emails, or irrelevant metadata. Removing noise results in a cleaner Gladly timeline. - Map old concepts to Gladly’s model
Map ticket IDs to conversation custom attributes. Map categories to topics. Map agents to Gladly agent IDs. This mapping document keeps everyone aligned and avoids mismatches during import.
What can be migrated via API into Gladly
Gladly’s API is quite flexible, but its data model is customer-driven. You’re not recreating tickets. You’re rebuilding the customer timeline.
Customers
You can create, update and retrieve customers with full profile data.
This includes:
- Names, emails, phone numbers
- Avatars and addresses
- Custom attributes defined in the Customer Profile Definition
- Unique customer IDs (auto-generated or provided)
Customers are the anchor for everything, so get them imported first.
Conversations
You can create, update and retrieve conversation metadata.
This includes:
- Inbox assignment
- Agent assignment
- Status changes (open, waiting, closed)
- Custom attributes
- Topics applied
Conversation items (the timeline)
Gladly exposes very granular control over conversation items.
You can import:
- Email messages
- Chat messages
- SMS messages
- Notes
- Customer activities
- Conversation status changes
- Topic changes
- Calls, phone metadata
- Voicemail records
- Rich content and message metadata
Items are imported with timestamps, which lets you preserve the natural order of message history.
Custom Attributes (Freeform Topics)
You can create and update custom attributes for conversations, which is perfect for migrating:
- Legacy ticket IDs
- Order numbers
- Product codes
- Workflow fields
These exist separately from customer-level attributes.
Topics
Topics are Gladly’s version of tags or categories.
You can:
- Create topics
- Get topics
- Update topics
- Add and remove topics on conversations
Useful when mapping legacy tags or categories.
Tasks
Tasks can be created, updated and retrieved via API.
You can preserve follow-up work by importing:
- Task description
- Assignee
- Due date
- Customer reference
- Comments on tasks
Notes
Internal notes can be added as conversation items.
SMS and Custom Channels
You can send outbound SMS through the Communications API and receive messages via Custom Channels after configuration in the UI.
What still needs to be configured in the Gladly UI
Gladly’s API is powerful, but it never replaces the workspace configuration that agents depend on day to day. These items must be set up manually in the Admin UI.
Inboxes and channel connections
All inboxes must be created and configured manually:
- Email channels
- Phone and IVR configuration
- SMS and WhatsApp numbers
- Chat and messaging entry points
- Custom Channel entry points
You cannot create inboxes or connect channels via the API.
Teams, roles and agent settings
Invite agents, assign roles and place them in the correct teams from the UI.
Gladly handles agent permissions manually, not through API.
Routing configuration
Gladly’s routing is based on inboxes, teams, availability and automation rules.
These must be configured manually:
- Assignment rules
- Availability flows
- Channel routing
- IVR behavior
- Topic-based flows
Help Center setup
If you use Answers and Help Center:
- Configure languages
- Audiences
- Help Center structure
- Collections, sections, ordering
API can manage Answers, but Help Center layout is UI-only.
Customer Lookup integrations
If you will use Lookup Adaptors, you must configure them in the UI and deploy your own service. This is not done in the main Gladly API.
Automation and rules
All automation in Gladly (rules, assignments, SLAs, channel triggers) lives in the UI.
API does not create automation.
Proactive Conversations
Campaigns are managed in the UI.
API can only add recipient collections to an existing campaign, not create the campaign itself.
Pre-migration setup in Gladly
Before you import anything, set up your Gladly workspace so the data lands in a stable, predictable environment.
- Create inboxes and connect all channels
Start by creating every inbox you plan to use.
Connect email addresses, phone numbers, chat entry points, Custom Channels and SMS numbers.
Make sure routing flows are working. Avoid sending live traffic into Gladly until after cutover. - Invite agents and create teams
Invite every agent who needs to exist in the system.
Remember that conversation ownership relies on existing agent IDs.
Assign roles and place agents in correct teams. - Create topics and custom attributes
Recreate your legacy categories as Topics.
Define any freeform attributes you will use for mapping legacy IDs, order numbers or custom data. - Configure Help Center and Answers library
Set up your Help Center structure if needed.
Create placeholders for major categories to make the migration smoother later. - Set up routing and rules but keep them paused
Build the skeleton of your routing rules now:
Which inboxes handle which channels, which teams own which tasks.
Keep automations turned off so they don’t fire during import.
6. Create API tokens and test connectivity
Create a dedicated API user and generate API tokens.
Run simple tests:
- Create a customer
- Retrieve a customer
- Create a conversation item
- Add a topic
- Add a note
This confirms your authentication and environment.
Migration Execution
This is where everything comes together. The quality of your planning shows here.
First run a sample migration of a small dataset of the messiest data you can find.
Verify if the sample migration was successful and adjust the mapping and fix the script bugs before the full migration.
Then start by importing customers so each conversation has a valid customer anchor. Then migrate conversations one at a time, preserving thread structure and timestamps by using correct conversation item content types (Email, Chat, SMS, Phone Call, Notes, Status Changes, and so on).
Watch your rate limits. Log errors and retry failures gracefully.
Once the full import is complete, run your delta import to catch new items created during the migration window.
Finally, update your routing and forward your email and messaging channels into Gladly.
Post-migration checklist
Data verification
Check that customer counts match expectations.
Verify a sample of conversations across different years and channels.
Look for missing items, incorrect timestamps, broken links or mis-threaded messages.
Routing and channel testing
Send test emails.
Send chat messages.
Make inbound calls if your phone system is connected.
Confirm that replies thread correctly in Gladly.
Agent workflows
Ask agents to test assignments, notes, topic changes, adding customer activities and performing follow-up tasks.
Help Center and Answers
Ensure Answers appear in the widget.
Test Help Center browsing and search.
Automation and webhooks
Turn on rules and event-based workflows after verification.
Check webhook delivery and confirm your services respond to Gladly PING events.
Stabilise the environment
Keep your old system in read-only mode for one or two weeks.
Track any mismatches and fix them quickly.
Common mistakes and pro tips
Here are the issues that appear over and over when teams migrate into Gladly.
- Importing before building the data model
Gladly requires customers up front. If you import conversations without customers first, mapping will break. - Forgetting to disable automation
If routing or automations stay on during import, agents may get flooded with alerts or customers may receive unwanted emails. - Not preserving timestamps on conversation items
Gladly’s timeline is chronological. If timestamps are wrong or missing, the timeline looks chaotic. - Skipping topic mapping
Topics power reporting. Map old categories to Topics early so your analytics stay meaningful after go-live. - Ignoring rate limits
Gladly enforces strict per-second request limits. If you push too fast, you’ll hit 429s. Build your importer with retries and backoff. - Not preparing agents
Gladly’s people-first model feels different from ticket-based tools. Teach agents how timelines, tasks, topics and customer views work. - Delta migrations done too late
Capture the last bit of change right before cutover. It keeps your data complete.