CRM migration
Field-level mapping, validation, and rollback between SendCloud and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
SendCloud
Source
Twenty CRM
Destination
Compatibility
6 of 10
objects map 1:1 between SendCloud and Twenty CRM.
Complexity
BStandard
Timeline
2-4 weeks
Overview
SendCloud is a purpose-built e-commerce shipping platform and does not function as a CRM, so a SendCloud-to-Twenty CRM migration is not a like-for-like platform swap but rather the extraction of any customer and address data from SendCloud into a new CRM foundation. We export SendCloud address records (ship-to and ship-from addresses attached to shipments and returns), parcel and shipment history, return data with reason codes, and any custom fields defined on parcels. Twenty CRM's standard objects—Companies, People, Opportunities, Tasks, Notes—receive this data via the REST API with custom objects created for Shipments and Returns since Twenty has no native shipping model. We do not migrate carrier-specific negotiated rates, live webhook subscriptions, or shop platform integration credentials; these require manual reconfiguration post-migration. We deliver a written inventory of any SendCloud return portal settings and carrier routing rules so the customer's team can rebuild these manually in Twenty or the carrier portal directly.
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 SendCloud object lands in Twenty CRM, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
SendCloud
Address
Twenty CRM
Company and People
1:manySendCloud stores ship-to and ship-from addresses as structured objects linked to Shipments and Returns. Ship-to addresses with a customer name map to Twenty People records; ship-from addresses (warehouse or business origin) map to Twenty Company records as the company's primary address. We deduplicate by address string during export and preserve the original SendCloud address_id as a custom field sc_address_id__c for reconciliation. Address validation rules differ between platforms; we flag any address records that fail Twenty's validation during import for manual correction.
SendCloud
Shipment
Twenty CRM
Custom Object: Shipment
1:1SendCloud Shipments represent the logical grouping of one or more Parcels sent to the same recipient address. We create a custom Shipment object in Twenty with fields for shipment_date, shipping_method, service_level, carrier, tracking_number, destination_address (lookup to People), and ship_from_address (lookup to Company). The SendCloud shipment_id becomes sc_shipment_id__c on the custom object for cross-reference. Historical shipment status (in_transit, delivered, returned) migrates as a select field.
SendCloud
Parcel
Twenty CRM
Custom Object: Parcel (linked to Shipment)
1:1SendCloud Parcels are the transactional unit with weight, dimensions, reference number, and status. We create a custom Parcel object in Twenty with fields for parcel_reference, weight, dimensions, status, and a lookup to the parent Shipment object. Each Parcel's shipment link is resolved at migration time using the SendCloud parcel_id-to-shipment_id relationship. Parcel custom fields (defined on certain SendCloud plans) migrate as custom fields on the Parcel object, created in Twenty before import.
SendCloud
Return
Twenty CRM
Custom Object: Return
1:1SendCloud Return requests track inbound parcels with return reason codes, return label data, and RMA status. We create a custom Return object in Twenty with fields for rma_number, return_reason, return_status, return_label_url, and lookups to the original Shipment (via sc_shipment_id__c) and the People record of the returning customer. Return reason codes are mapped to a select field with options sourced from SendCloud's available codes during scoping.
SendCloud
User
Twenty CRM
People (Account Owner)
1:1SendCloud User accounts with shipping operations roles map to Twenty People records. We extract user name, email, and role assignments from SendCloud and create corresponding People records in Twenty. Role assignments are stored as a text field since Twenty's permission model is workspace-scoped and not directly equivalent to SendCloud's account-level role structure. Active SendCloud users without a matching email in Twenty are held in a reconciliation queue for the customer's admin to provision.
SendCloud
Custom Fields (Parcels and Returns)
Twenty CRM
Custom Fields on Parcel and Return objects
lossySendCloud custom fields defined on Parcels and Returns are account-specific and exposed partially via API. We inventory all custom fields during scoping, map their data types to equivalent Twenty field types (text, number, date, select, multi-select), create the fields in Twenty's Settings → Data Model before import, then populate them during the data load. Any custom fields with unsupported data types are flagged for manual migration post-load.
SendCloud
Webhook Subscriptions
Twenty CRM
Webhook Subscriptions (re-establishment)
1:1SendCloud webhook endpoint configurations are exported during scoping as a written inventory document. We do not migrate live webhook connections because they are tied to SendCloud credentials and will not function at Twenty. The inventory includes the endpoint URL, event type (parcel_status, shipment_created, return_initiated), and payload schema for each webhook so the customer's development team can recreate these in Twenty's webhook configuration. This is a manual rebuild task outside migration scope.
SendCloud
Integrations
Twenty CRM
Integrations (re-establishment)
1:1SendCloud's native integrations with Shopify, WooCommerce, Magento, PrestaShop, and other shop platforms are inventoried during scoping. We export integration configuration settings (API keys, webhook URLs, sync settings) as a written document for the customer's admin to reconfigure in the destination platform. Twenty has no native Shopify or WooCommerce integration; the customer will need to build a custom integration via Twenty's REST or GraphQL API, use an iPaaS tool like Zapier or n8n, or engage a developer. This is documented as a post-migration configuration task.
SendCloud
Carrier
Twenty CRM
Select field on Shipment
lossyCarriers defined in SendCloud's routing rules map to a select field on the custom Shipment object in Twenty. We create a carrier__c select field with options sourced from the active carrier list in the SendCloud account. Carrier-specific routing rules (which are SendCloud-stored workflow configurations) are documented in the integration inventory for manual rebuild. Merchant-specific negotiated carrier rates are not exported from SendCloud and do not migrate; this is flagged as a high-severity gotcha before migration begins.
SendCloud
Shipping Labels
Twenty CRM
URL field on Parcel
lossySendCloud shipping label binary files are not migrated as they are carrier-generated PDF or ZPL files stored in SendCloud's file system. We create a label_url__c text field on the Parcel object and populate it with the SendCloud label URL if accessible via API during the export window. Post-migration, the customer regenerates labels from the carrier portal directly using the tracking number and shipment data migrated to Twenty. Label format preferences (size, branding) are documented for manual reconfiguration at the carrier level.
| SendCloud | Twenty CRM | Compatibility | |
|---|---|---|---|
| Address | Company and People1:many | Fully supported | |
| Shipment | Custom Object: Shipment1:1 | Fully supported | |
| Parcel | Custom Object: Parcel (linked to Shipment)1:1 | Fully supported | |
| Return | Custom Object: Return1:1 | Fully supported | |
| User | People (Account Owner)1:1 | Fully supported | |
| Custom Fields (Parcels and Returns) | Custom Fields on Parcel and Return objectslossy | Fully supported | |
| Webhook Subscriptions | Webhook Subscriptions (re-establishment)1:1 | Mapping required | |
| Integrations | Integrations (re-establishment)1:1 | Mapping required | |
| Carrier | Select field on Shipmentlossy | Fully supported | |
| Shipping Labels | URL field on Parcellossy | 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.
SendCloud gotchas
Carrier-specific rate negotiated rates do not transfer
Webhook and integration credentials must be re-established
Free tier parcel cap is easy to exceed during migration
Return workflow configurations are account-specific
Twenty CRM gotchas
Import order is enforced and critical
Export limited to 20,000 records and visible columns only
Soft-deleted records count toward uniqueness and trigger restores
API rate limits cap at 200 req/min on Organization tier
No native email sequences — follow-up cadences require external tools
Pair-specific challenges
Migration approach
Account scoping and plan assessment
We audit the SendCloud account across plan tier (Free/Lite/Growth/Premium/Enterprise), API access scope, historical parcel and shipment volume, active custom fields on Parcels and Returns, carrier routing rules, webhook subscriptions, and shop platform integrations. We extract the full list of active integrations and webhook endpoints during this phase. The scoping output is a written migration scope document with record counts per object, a list of custom fields to create in Twenty, and a flag for any carrier rate dependencies. We recommend any temporary SendCloud plan upgrade required to avoid free-tier parcel cap interruption during export.
Twenty workspace preparation
We create the Twenty workspace by setting up the data model before any data import. This includes creating the custom Shipment, Parcel, and Return objects via Settings → Data Model, adding all custom fields (carrier__c, sc_shipment_id__c, sc_address_id__c, return_reason, rma_number, and any parcel custom fields sourced from SendCloud), and configuring select field options for status values and carrier names. We invite all team members via Settings → Members before import so that any owner or assignee references in the migrated data resolve correctly.
Export from SendCloud
We export SendCloud data via CSV and API in dependency order: Addresses first (to resolve lookups), then Users, then Shipments (with parcel count and carrier data), then Parcels (linked to shipments), then Returns (linked to original shipment and customer). We handle pagination and chunking for accounts with large historical volumes. Webhook endpoint configurations and integration settings are documented as written inventories rather than extracted as portable credentials.
Data transformation and field mapping
We transform the exported SendCloud data against the mapping document created during scoping. Address records are split into Twenty People (ship-to) and Company (ship-from) records with deduplication. Shipment records are created as custom Shipment object records with carrier, tracking number, and destination address lookups resolved. Parcel records are linked to parent Shipment records via the sc_shipment_id__c reference. Return records are linked to both the original Shipment and the People record of the returning customer.
Sandbox import and reconciliation
We run a test import into a Twenty sandbox or trial workspace to validate the data model, field mappings, and lookup resolution before production migration. The customer's team spot-checks 20-30 records against the SendCloud source for accuracy (addresses, shipment dates, tracking numbers, return status). Any field mapping corrections or custom field additions are made in Twenty's data model, and the test import is repeated until the customer signs off. This step prevents data integrity issues in production.
Production migration and cutover
We run the production migration in dependency order: Companies and People first, then Shipments, then Parcels (linked to shipments), then Returns. Each phase emits a row-count reconciliation report before the next phase begins. We freeze SendCloud writes during the cutover window, run a final delta import of any records modified during migration, then enable Twenty as the system of record for customer and shipment tracking. We deliver the webhook and integration inventory document for the customer's development team to rebuild post-migration.
Platform deep dives
SendCloud
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 2 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across SendCloud and Twenty CRM.
Object compatibility
2 of 8 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
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
SendCloud: Not publicly documented.
Data volume sensitivity
SendCloud 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 SendCloud to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your SendCloud to Twenty CRM migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave SendCloud
Other ways to arrive at Twenty CRM
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.