Odoo for E-commerce on Shopify:
The Full Integration Guide for 2026

Why a Growing Shopify Store Needs a Real ERP

The Shopify admin looks complete because it covers the revenue side of the business — storefront, checkout, orders, basic inventory. What it doesn't cover is everything that happens after the order: multi-channel inventory reconciliation, multi-warehouse routing, wholesale pricing, procurement, returns at scale, and financial consolidation across brands. Those are ERP problems, and Shopify's app ecosystem solves them only partially.

Inventory Across Channels

A store with one Shopify channel and one warehouse rarely has inventory problems. Add a second sales channel — Amazon, Faire, a wholesale portal, a second Shopify store for a sister brand — and the math breaks immediately. Shopify Locations can track stock per warehouse, but it cannot arbitrate across channels. If the same SKU is listed on Shopify and Amazon, you need a master inventory authority that pushes availability to every channel. Shopify isn't that authority; it's a consumer of inventory data, not the source of truth.

Multi-Warehouse Routing

Multi-warehouse in Shopify means multi-location stock tracking. It does not mean intelligent fulfillment routing. When a customer in Texas orders three items — two stocked in your Dallas warehouse, one in New Jersey — Shopify won't split the shipment optimally. It will either ship everything from one location (adding freight cost) or require a manual decision. An ERP models each warehouse as a stock location with transfer rules, allowing automatic order splitting, inter-warehouse transfers, and routing based on proximity, stock level, or cost.

Wholesale + Retail in the Same Catalog

Shopify B2B (Plus tier) handles wholesale logins, price lists, and net-terms orders, but it treats B2B as a parallel storefront — not as an integrated channel. The same SKU sold at $25 retail and $14 wholesale needs a single cost of goods, a single inventory pool, unified purchase reorder logic, and consolidated margin reporting. Running these as two Shopify stores means duplicating product data, reconciling inventory twice, and producing two sets of reports that never quite add up.

Accounting Beyond Shopify Reports

Shopify reports revenue. They don't report profit by SKU, landed cost with freight and duty allocated, inventory valuation using FIFO or weighted average, or contribution margin by channel. They don't handle inter-company transactions if you have a holding company. They don't produce a trial balance. Most Shopify stores solve this by exporting orders to QuickBooks or Xero — which works until you hit multi-entity, multi-currency, or product-level margin reporting, at which point the bookkeeper starts rebuilding spreadsheets.

B2B Pricing Logic

Real B2B pricing is not a simple discount column. It's tiered by volume, negotiated per customer, sometimes per product family, with payment terms, credit limits, and approval workflows. Shopify B2B covers the basics; anything complex — "Distributor tier A gets 38% off SKUs in category X, 32% off category Y, with a 2% early-payment discount if paid within 10 days" — becomes untenable without a dedicated pricing engine. Odoo handles this natively with pricelists, payment terms, and credit-limit enforcement on sales orders.

Returns and Refunds at Scale

One return a day is manageable in Shopify. Fifty returns a day — typical for fashion and footwear DTC — is not. Each return needs inventory disposition (restock, refurbish, scrap), refund accounting (which payment method, which tax treatment, which warehouse the item went back to), and margin adjustment. Doing this inside Shopify plus a returns app plus QuickBooks plus a 3PL dashboard means nobody knows the actual state of a return at any given moment. An ERP consolidates the return lifecycle into one record with accounting, inventory, and operations updated atomically.

Integration Architecture: Three Patterns That Work (And Why)

The integration layer is where most Shopify + Odoo projects succeed or fail. There are three viable patterns in 2026, each with different trade-offs around cost, customization, and maintenance burden. Pick the wrong one and you'll spend six months fighting sync bugs; pick the right one and the integration becomes invisible infrastructure.

Pattern 1: Odoo's Native Shopify Connector

Odoo ships an official Shopify connector as part of the Sales module. It's the default starting point and covers 80% of standard use cases out of the box. The connector authenticates via a Shopify custom app (API key + access token), then synchronizes five object types: products, variants, inventory levels, orders, and customers. You configure sync direction and frequency per object type in the connector's settings.

SYNCED BY DEFAULT
  Products           Odoo -> Shopify    (name, description, variants, images)
  Inventory levels   Odoo -> Shopify    (per Shopify Location)
  Orders             Shopify -> Odoo    (creates sales order + invoice)
  Customers          Shopify -> Odoo    (creates res.partner)
  Payments           Shopify -> Odoo    (posts to configured journal)

NOT SYNCED (GAPS TO FILL)
  Refunds            Partial             (requires custom handler for partial refunds)
  Fulfillment        Partial             (Odoo pushes tracking; Shopify multi-location splits incomplete)
  Product metafields No                  (requires REST API extension)
  Draft orders       No
  B2B price lists    No                  (Shopify B2B is a separate API surface)
  Gift cards         No
  Subscriptions      No                  (needs third-party subscription app + custom bridge)

The native connector is the right choice when you run a single Shopify store, sell DTC retail only, use Shopify's standard payment and fulfillment flows, and don't rely heavily on metafields, subscriptions, or gift cards. When those gaps matter — and for most stores past $3M GMV they do — you extend the connector with custom handlers or move to pattern 2.

Pattern 2: Direct API Integration (REST + Webhooks)

The direct pattern skips the prebuilt connector and wires Shopify's REST and GraphQL APIs to Odoo via a custom module. Shopify pushes events via webhooks (order/create, order/updated, refund/create, fulfillment/create, inventory_level/update) to an Odoo endpoint that validates the HMAC signature, parses the payload, and writes to the appropriate Odoo model. Outbound sync — products, inventory — runs as scheduled cron jobs calling Shopify's Admin API.

import hmac
import hashlib
import base64
import json
from odoo import http
from odoo.http import request

class ShopifyWebhookController(http.Controller):

    @http.route('/shopify/webhook/order/create', type='json',
                auth='public', csrf=False)
    def order_create(self, **kwargs):
        # 1. Validate HMAC signature
        raw_body = request.httprequest.data
        shopify_hmac = request.httprequest.headers.get(
            'X-Shopify-Hmac-Sha256', ''
        )
        secret = request.env['ir.config_parameter'].sudo().get_param(
            'shopify.webhook_secret'
        )
        digest = base64.b64encode(
            hmac.new(secret.encode(), raw_body, hashlib.sha256).digest()
        ).decode()
        if not hmac.compare_digest(digest, shopify_hmac):
            return {'error': 'invalid hmac'}

        # 2. Parse payload and queue for processing
        payload = json.loads(raw_body)
        request.env['shopify.order.queue'].sudo().create({
            'shopify_order_id': payload['id'],
            'payload': raw_body.decode(),
            'state': 'pending',
        })
        return {'status': 'queued'}

Direct integration is the right choice when you need full control: custom metafield mapping, non-standard fulfillment rules, subscription logic, multi-store unification, or high-volume order throughput where the prebuilt connector's batch sync cadence becomes a bottleneck. It's also the right pattern if you need idempotent order processing — webhooks can fire twice, and the queue-then-process pattern lets you deduplicate on shopify_order_id before creating the Odoo sales order.

Pattern 3: Third-Party Middleware (Celigo, Make, Zapier)

Middleware platforms sit between Shopify and Odoo and handle the sync plumbing through a visual interface. Celigo's integrator.io has a prebuilt Shopify + NetSuite template that's often adapted for Odoo with minor modifications. Make (formerly Integromat) and Zapier offer DIY integration scenarios for simpler flows. The advantage: faster time to first sync, no custom Python, and visual error handling.

What Actually Syncs: The Five Object Flows

Regardless of pattern, every Shopify + Odoo integration comes down to five object flows. Get these right and the integration works; get any one wrong and the business breaks.

Product catalog sync should flow Odoo → Shopify. Odoo is the master product record (SKU, cost, weight, dimensions, categorization), and Shopify is the publication channel (title, description, images, SEO fields). Create products in Odoo, mark them as "publish to Shopify," and the connector pushes the Shopify-specific fields. Never create products directly in Shopify — you'll end up with orphaned SKUs that have no cost or purchase data in Odoo.

Inventory sync also flows Odoo → Shopify, scoped per Shopify Location. Each Odoo warehouse maps to a Shopify Location. On-hand quantity updates push in near-real-time (webhook on stock.move confirmation), so Shopify's available-to-sell quantity mirrors actual physical stock. Avoid the opposite direction — if Shopify is the inventory authority, the first time someone does a manual inventory adjustment in Odoo the two systems drift silently.

Order sync flows Shopify → Odoo. Shopify captures the order, charges the card, and fires an order/create webhook. Odoo creates a sales order linked to the Shopify order ID, confirms it, generates the delivery order, and (depending on configuration) creates the invoice. The Shopify order ID is stored on the Odoo sales order as an external reference for reconciliation.

Customer sync flows Shopify → Odoo, with match logic on email. First-time buyers create a new res.partner; returning buyers match on email and append the new order to the existing partner. Edge case: a B2B buyer who also places DTC orders with a personal email. The default match-by-email logic links them incorrectly — handle this by storing the Shopify customer ID on the partner and matching on that first.

Fulfillment sync flows Odoo → Shopify. When a delivery order ships in Odoo (validation of the outgoing transfer), the connector pushes a fulfillment creation to Shopify with carrier, tracking number, and tracking URL. Shopify then emails the customer and updates the order status. The return path — Shopify cancellations and refunds — flows back to Odoo as sales order cancellations or refund invoices.

Three Real-World Use Cases

Case A: $3M DTC Brand Unifying Two Shopify Stores

A skincare brand ran two Shopify stores — a US store and a Canada store — each with its own inventory, its own products, and its own QuickBooks file. They acquired a second product line and needed to launch a third store without tripling their bookkeeping. We built a single Odoo Enterprise instance with three companies (US, Canada, Product Line 2), shared the product catalog across all three, and connected each Shopify store via the native connector scoped to its company. Inventory stayed warehouse-specific, but purchasing and product data unified. Bookkeeping time dropped from 12 hours/week to 3 hours/week, and they launched the third brand in 6 weeks instead of the projected 6 months.

Case B: B2B Distributor Adding Shopify as Retail Front

A specialty food distributor had been running Odoo for five years for wholesale — EDI orders from grocery chains, purchase orders to 40 suppliers, multi-warehouse routing across three US DCs. They wanted to add a DTC channel to move slow-moving SKUs direct to consumers. We set up a Shopify store as a retail front, connected it to a dedicated Odoo warehouse that drew from DC1 overstock, and configured pricing so retail prices carried a 60% margin versus 18% wholesale. Orders from both channels flowed into the same Odoo, with consolidated reporting showing channel-level margin. The DTC channel hit $400K GMV in year one with zero additional staff.

Case C: Subscription Box Company with Complex Fulfillment

A monthly subscription box company used Shopify + Recharge for subscription management. They hit scale problems: 8,000 active subscribers meant 8,000 recurring orders processed on the 1st of each month, each with a personalized product mix. Shopify handled the recurring charge, but fulfillment routing and component assembly were manual. We integrated via direct API (pattern 2), with Recharge's subscription events triggering Odoo manufacturing orders that assembled boxes from component inventory. Odoo then pushed fulfillment back to Shopify. Processing time dropped from 4 days to 6 hours, and the operations team scaled from 4 FTEs to 2 while subscriber count grew 40%.