Shopify + Salesforce Integration
Orders, customers, and products flow from Shopify into Salesforce so sales and service work from one record. The decision that shapes the whole project is which Salesforce object an order becomes.
- mode:
- Shopify → Salesforce (bidirectional optional)
- latency:
- Near real-time
- maturity:
- Production-tested
what syncs
What syncs, which way, and how fast
Every row is a real data flow with a real trigger. The frequency column is what you should expect in production, not a best case.
Customers
- dir:
- Shopify → Salesforce
- frequency:
- Near real-time
Contact, optionally under an Account for B2B. Dedupe strategy must be settled before the first sync or you inherit a mess.
Orders
- dir:
- Shopify → Salesforce
- frequency:
- Near real-time
Custom object for most B2C, Opportunity only when a rep genuinely works the deal. Getting this wrong corrupts forecasting.
Products
- dir:
- Shopify → Salesforce
- frequency:
- Hourly
Product2 plus PricebookEntry so order line items reference real SKUs and revenue reporting works.
Fulfillment
- dir:
- Shopify → Salesforce
- frequency:
- Near real-time
Shipment status and tracking on the order record so Service Cloud agents answer without leaving Salesforce.
Cases
- dir:
- Bidirectional
- frequency:
- Near real-time
Optional. Order context on cases, and case status back to Shopify order notes when support needs it visible both sides.
Accounts
- dir:
- Bidirectional
- frequency:
- Near real-time
B2B only. Company-level rollups of order history, which needs Shopify B2B objects and therefore Plus.
architecture
How it actually works
Salesforce has no first-party Shopify connector, so this is always middleware or custom. API request limits are per-org per 24 hours, which makes request budgeting a first-class design concern.
Shopify webhooks + queue
Order, customer, and fulfillment events queue before hitting Salesforce so a limit-exhausted org never causes webhook failures upstream.
Middleware or MuleSoft
Celigo, Workato, or MuleSoft where you already own it. Custom middleware when the object model is unusual or licence cost outweighs a build.
Composite and Bulk APIs
The critical choice. Composite requests batch related writes and Bulk API 2.0 handles backfills, because naive per-record REST calls will exhaust a daily allocation.
Dedupe and matching layer
Normalised email matching with Salesforce duplicate rules, resolved before write. Retrofitting dedupe after go-live is materially more expensive than designing it in.
Platform Events (optional)
For reverse flows, Platform Events let Salesforce changes trigger Shopify updates without polling.
failure modes
What breaks, and what happens when it does
Every integration fails eventually. The difference between a good one and a bad one is whether it fails safely and tells you.
Daily API request limit exhaustion
Sync stops mid-afternoon and resumes at midnight, with a gap nobody can explain.
handling
Limits are per-org per 24 hours and shared with every other integration you own. We budget requests, batch through Composite, move backfills to Bulk API 2.0, and monitor consumption as a first-class metric.
Orders as Opportunities wrecking forecasts
Pipeline reports become meaningless once thousands of web orders arrive.
handling
Opportunities are reserved for deals a human works. High-volume B2C orders go to a custom object with their own page layouts and reports, keeping forecasting intact.
Duplicate contacts and accounts
Service agents find three records for the same customer, each with partial history.
handling
Emails are normalised, Salesforce duplicate rules are enforced, and matching happens before insert. Ambiguous matches queue for review rather than auto-merging, since a bad merge is far harder to unwind.
Governor limits in triggers
Bulk syncs fail with limit exceptions that never appeared in testing.
handling
All Apex in the sync path is written bulk-safe, with no queries or DML inside loops. Heavy work moves to Queueable or Batch Apex, and we test at production volume rather than with ten records.
Person Account versus Contact model
A B2C-friendly data model turns out to be incompatible with the org configuration.
handling
Person Accounts are irreversible once enabled, so the model is decided in discovery with your Salesforce admin. It is one of the few genuinely one-way doors in this project.
Currency and tax rounding mismatches
Salesforce revenue reports disagree with Shopify by small amounts that compound.
handling
Multi-currency is configured explicitly with Shopify presentment currency preserved, and tax is stored as its own field rather than folded into line totals. Reconciliation happens at line level.
field mapping
A real slice of the mapping
This is an abridged Order → Salesforce (custom object) mapping, shown so you can sanity-check it against your own system.
Order → Salesforce (custom object)
shopify → salesforce
order.nameShopify_Order__c.Nameorder.idShopify_Order__c.External_Id__cUpsert key
order.total_priceShopify_Order__c.Amount__ccustomer.emailContact.EmailNormalised for dedupe
line_item.skuOrder_Line__c.Product__cVia Product2 lookup
fulfillment.tracking_numberShopify_Order__c.Tracking__ctotal_taxShopify_Order__c.Tax__cSeparate field
Assumes the custom object model. Opportunity or Order object mapping differs and is decided with your Salesforce admin.
implementation
Timeline and cost
typical duration
6 to 12 weeks
included in scope
- Object model design and dedupe strategy
- Four objects syncing with the matrix above
- API request budgeting and consumption monitoring
- Bulk-safe Apex and Composite request batching
- Page layouts and reports for the new data
- UAT in a full sandbox plus hypercare
what moves it up
- Bidirectional sync with Platform Events
- Historical order and customer migration
- Service Cloud case and order-context build-out
- B2B account hierarchies requiring Shopify Plus
- Multi-currency and multi-org consolidation
questions
Questions buyers actually ask
Should Shopify orders become Opportunities or a custom object?
A custom object for high-volume B2C, because Opportunities carry forecasting and pipeline semantics that thousands of web orders destroy. Reserve Opportunities for deals a human actually works, such as large wholesale negotiations. This decision is expensive to reverse once reports and automation are built on it.
Does Salesforce have a native Shopify connector?
No first-party connector exists. You use middleware such as Celigo, Workato, or Boomi, MuleSoft if you already own it, or a custom integration. AppExchange listings tend to cover basic one-way sync, so verify they handle your object model before committing.
What are Salesforce API limits and will we hit them?
Salesforce allocates a fixed number of API requests per org per 24 hours based on edition and licence count, shared across every integration you run. A naive per-record integration on a busy store can exhaust it, so we budget requests, batch with Composite, use Bulk API 2.0 for backfills, and monitor consumption continuously.
How do you prevent duplicate contacts?
Emails are normalised before matching, Salesforce duplicate rules are enforced, and existing records are resolved before any insert. Ambiguous matches queue for human review instead of auto-merging, because an incorrect merge is considerably harder to undo than a duplicate record.
Should we use Person Accounts for B2C customers?
It depends on your existing org, and it is a genuine one-way door: enabling Person Accounts cannot be reversed. If your org already uses them, follow that model. If not, the standard Contact model with a custom order object usually serves e-commerce better. Decide with your Salesforce admin during discovery.
Can data flow from Salesforce back to Shopify?
Yes, though most projects start one-way. Platform Events can push Salesforce changes to Shopify without polling, typically to write customer tags, service state, or account tiers. Add it once the inbound direction is stable rather than building both at once.
shopify + salesforce
Get the object model right before you build
The expensive mistakes here are architectural, not technical. Tell us your Salesforce edition and order volume and we will map the objects before anyone writes code.