Updated: 2026. In eCommerce, a CRM without integrations is just a contact list. To actually improve sales and service, your CRM must see the full chain: order → payment outcome → shipping → refunds/returns → repeat purchases, while keeping marketing attribution (UTM) and support history in one place.
TL;DR: critical integrations (P0–P2)
- P0 (must-have): Shopify/WooCommerce (orders+customers+statuses), payments (paid/refund/chargeback), shipping/fulfillment (tracking+delivered/exception).
- P1 (high impact): UTM attribution (first/last touch), support/helpdesk (return/cancel reasons, SLA, CSAT).
- P2 (scale stage): inventory/ERP (stock/ETA), finance (fees/net), BI (LTV/ROMI/cohorts).
Table of contents
- What data a CRM must “see” in eCommerce
- Integration table: what to sync and why
- Shopify → CRM: critical fields and events
- WooCommerce → CRM: plugin pitfalls
- Payments → CRM: statuses, refunds, chargebacks
- Shipping/fulfillment/returns: tracking and reasons
- UTM attribution: how not to lose sources
- Data quality: dedupe, external IDs, idempotency
- Implementation roadmap
- FAQ
What data a CRM must “see” in eCommerce
In eCommerce, “Customer 360” matters more than a single deal record. At minimum, your CRM should unify customer profile, orders, payment outcomes, shipping timeline, refunds/returns, and support interactions.
- Customer: email, phone, name, geo/language, consent, first/last source.
- Order: order_id, created_at, total, currency, discounts/coupons, line items, statuses.
- Payment: payment_status, method, transaction_id, fee, net_amount, refunded_amount.
- Shipment: carrier, tracking_number, shipment_status, shipped_at, delivered_at, returned_at.
- Return/Refund: partial/full, reason, items, amount, resolution (refund/replace/store credit).
- Support: tickets, reason tags, SLA/response time, CSAT/NPS.
Integration table: CRM integrations for eCommerce
| Integration | What to sync | Why it matters | Priority |
|---|---|---|---|
| Shopify/WooCommerce | Customers, orders, line items, coupons, statuses | Single source for revenue and repeat purchases | P0 |
| Payments | paid/failed, refunds (partial/full), chargebacks, fees | Source of truth for “paid” + correct LTV/margin | P0 |
| Shipping/Fulfillment | tracking, carrier, shipment_status, timestamps | Post-delivery automation + proactive support | P0 |
| UTM Attribution | first/last UTM, landing page, referrer, click IDs (if possible) | ROMI/ROAS and channel clarity | P1 |
| Helpdesk/Chat | tickets, return/cancel reasons, CSAT, SLA | Segmentation and lower return rates | P1 |
| Inventory/ERP | stock, ETA/backorder, COGS (if available) | Less overselling and more accurate margin | P2 |
Shopify → CRM: what’s critical
With Shopify, don’t just sync orders. Sync lifecycle events that drive automation and accurate reporting.
Must-have fields
- Customers: email, phone, consent, addresses, tags/segments.
- Orders: order_id/number, totals, discounts, taxes, shipping, currency.
- Line items: sku/product_id, qty, price.
- Statuses: paid/unpaid, fulfilled/unfulfilled, cancelled (+ timestamps).
- Refunds: amount, items, timestamp (partial/full).
Common pitfalls
- Customer duplicates (email vs phone) due to missing merge rules.
- Refunds not synced → inflated revenue/LTV and broken segments.
- No delivered event → “post-delivery review” automations don’t fire.
WooCommerce → CRM: plugin pitfalls
WooCommerce stacks vary by plugins. For stability, normalize events and statuses via webhooks (webhooks → integration layer → CRM).
- Status mapping: processing/completed/cancelled/refunded (+ timestamps).
- Customer fields: billing/shipping email/phone, addresses.
- Tip: treat the payment provider as the source of truth for “paid”.
Payments → CRM: must-have
Your payment provider is the source of truth for paid, refunds, partial refunds, disputes, and chargebacks.
- Events: payment_succeeded, payment_failed, refund_partial/refund_full, dispute/chargeback.
- Fields: transaction_id, payment_method, amount, currency, fee, net_amount, refunded_amount.
Shipping/fulfillment/returns
When your CRM sees shipping updates, you reduce “Where is my order?” tickets and can automate: delivered → review request, exception → proactive support, returned → retention workflow.
- Shipment: carrier, tracking_number, shipment_status, shipped_at, delivered_at, returned_at.
- Return: reason codes (size/defect/late), items, refunded_amount, resolution.
UTM attribution: don’t lose sources
At minimum, store first and last UTM values and carry them to the order. Otherwise ROMI/ROAS becomes guesswork.
- first_utm_source/medium/campaign
- last_utm_source/medium/campaign
- landing_page, referrer, (if possible) gclid/fbclid
Data quality: dedupe, external IDs, idempotency
- Dedupe: define a primary key (often email) + merge rules for phone.
- External IDs: store Shopify/Woo customer_id/order_id in the CRM.
- Idempotency: keep event_id/transaction_id to prevent duplicates when webhooks retry.
Implementation roadmap
- Define sources of truth: store, payments, shipping.
- Set customer key + merge rules + external IDs.
- Sync Shopify/Woo → CRM (orders/customers/statuses).
- Sync payments → CRM (paid/failed/refund/dispute + fees).
- Sync shipping → CRM (tracking + status timeline).
- Add UTM capture and carry it to orders.
- Add helpdesk tickets and return/cancel reasons.
- Test edge cases (partial refunds, split shipments, address changes).
FAQ
Do I need payment webhooks if Shopify shows “paid”?
Sometimes for basic ops. But for refunds, partial refunds, disputes/chargebacks, and fees, webhooks from the payment provider are far more reliable.
What’s the minimum integration stack for a small store?
P0: store platform sync + payments + shipping. Then add UTM and support as you scale.