Migrate from Keeping to Gorgias

Keeping tickets are the primary data object and map directly to Gorgias Ticket. We extract the ticket subject, body, channel of origin (email or Slack), status, assignee (by email resolution to Gorgias User), priority, and tags from the Slack thread. The original Slack thread timestamp becomes the Gorgias created_datetime and last_message_datetime fields. Custom properties stored in Slack message metadata (such as order numbers or internal tracking flags) map to Gorgias custom fields on Ticket, which we pre-create via the Gorgias API using the external_id, object_type=Ticket, label, and definition structure.

Keeping does not have a standalone Customer object; customer data lives inside ticket metadata as email addresses, names, and sometimes phone numbers extracted from Slack thread context. We reconstruct the customer record by iterating every ticket, extracting unique customer identifiers, and deduplicating by email. The reconstructed Customer record maps to Gorgias Customer with email, name, phone, and any extracted e-commerce identifiers. Customer external_id is set to the Keeping ticket ID for traceability. If no email is present in the thread, we flag that record for manual review during migration.

Keeping organizes tickets by Slack Channel, and each channel represents a support queue or topic. We treat Slack Channels as Gorgias Tags on the Ticket object, preserving the channel-to-tag relationship so that Gorgias agents can filter by the original Keeping queue. Alternatively, if the customer uses Slack Channels as routing rules (e.g., billing-channel routes to a billing team), we convert these to Gorgias Macros with routing actions, though macros are not migrated as code and require rebuild.

Keeping email tickets contain a message thread with sender, recipient, subject, and body. These map to Gorgias Ticket Messages in chronological order. We preserve the original sender email address, timestamp, and message body (plain text or HTML). Any inline images in email bodies migrate as embedded assets linked to the message.

Slack thread replies from agents and customers are captured as ticket messages in Keeping. We map each Slack thread message to a Gorgias Ticket Message with the same timestamp sequence, preserving the conversation order. The Slack message author maps to the Gorgias User by email resolution. Customer replies in the Slack thread map to customer-side messages in the Gorgias ticket.

Keeping tickets attached to Slack messages may contain files (screenshots, PDFs, order exports). We extract these from the Slack thread export and attach them to the corresponding Gorgias Ticket Message. We flag any attachments that were stored as Slack message files but are inaccessible due to workspace permission changes or deleted workspace files. Attachments migrate as binary blobs via the Gorgias API, preserving filename and MIME type.

Keeping Agents are Slack workspace members who have been given access to specific channels. We resolve Keeping agents to Gorgias Users by email match. Any agent without an email in the Keeping export is flagged in the reconciliation queue. We provision the Gorgias Users (name, email, role) before ticket import so that assignee resolution is satisfied at insert time.

Email addresses extracted from Keeping tickets become the primary identifier on the Gorgias Customer object. The email address is set as the Customer.email field and used as the dedupe key during import. If the same customer appears across multiple tickets (same email address), we merge them into a single Gorgias Customer with multiple associated tickets.

Keeping derives ticket creation time from the first Slack message in the thread. We preserve this as the Gorgias Ticket created_datetime and last_message_datetime fields. This is critical for SLA reporting in Gorgias and for historical audit. We do not reset timestamps to migration time; the original Slack timestamp is the system of record.

Keeping supports channel-based tagging and any custom tags applied by agents. We extract all tags from the Keeping ticket metadata and map them to Gorgias Tags on the Ticket. Tags are stored as string arrays in Gorgias. If tags represent categories (billing, shipping, refund), they map directly; if tags represent internal routing (assigned-to-jane, escalated), we document them for the customer's admin to configure as Gorgias Rules or Macros post-migration.

Keeping stores some custom metadata in Slack message properties (such as order IDs, internal tracking codes, or source attribution). We extract these as key-value pairs and create matching Gorgias custom fields on the Ticket or Customer object via the Gorgias API. The custom field definition must specify the type (boolean, number, text) and the object_type (Ticket or Customer). We pre-create these fields before any record import.

If Keeping has been used to share knowledge base articles via Slack (less common), we extract these as plain-text documents and map them to Gorgias Help Center Articles. Gorgias supports article creation via API with title, body, and publication status. This is a lower-confidence migration path because Keeping has no native knowledge base feature; articles are typically shared as Slack messages and require manual content extraction.