Intégration Shopify + Odoo ERP : Le guide complet

À mesure que les magasins Shopify évoluent, l’écart entre ce que Shopify gère nativement et ce dont l’entreprise a réellement besoin pour atteindre l’excellence opérationnelle devient une contrainte importante. Gestion des stocks dans plusieurs entrepôts, comptabilité multidevises, commandes de fabrication déclenchées par les ventes Shopify, CRM sophistiqué avec historique complet des clients et réapprovisionnement automatisé des fournisseurs : tout cela nécessite un ERP, et Odoo est de plus en plus le système de choix pour les entreprises de commerce électronique de taille moyenne.

Shopify + Odoo n'est pas une intégration plug-and-play. Cela nécessite des décisions architecturales minutieuses quant à savoir quel système possède quelles données, ce qui est synchronisé dans quelle direction et comment gérer les cas extrêmes tels que les expéditions partielles, le traitement des retours et le mappage des variantes. Ce guide couvre tout, de l'architecture d'intégration aux modèles de mise en œuvre spécifiques.

Points clés à retenir

• Odoo est la source de vérité pour l'inventaire, les clients et la comptabilité ; Shopify est la source de vérité pour les transactions de commerce électronique
• La synchronisation bidirectionnelle des stocks (Shopify → Odoo pour les commandes, Odoo → Shopify pour les niveaux de stock) est la principale exigence d'intégration
• La gestion du catalogue de produits doit résider dans Odoo et se synchroniser avec Shopify – et non l'inverse
• Les enregistrements clients fusionnent entre les systèmes en utilisant le courrier électronique comme identifiant unique
• Cycle de vie de la commande : Shopify crée la commande → Odoo reçoit la commande → Odoo crée la livraison → met à jour l'exécution Shopify
• Le traitement des retours nécessite une coordination : Shopify initie le retour → Odoo traite la réception → la mise à jour des deux systèmes
• L'API Webhook de Shopify fournit des événements de commande en temps réel ; Odoo les reçoit via le middleware du connecteur
• Des connecteurs directs Odoo-Shopify existent (Syncee, OdooConnector) mais des intégrations personnalisées via l'API REST offrent plus de contrôle

---

Comprendre l'architecture d'intégration

Avant la mise en œuvre, définissez le système faisant autorité pour chaque domaine de données :

Pourquoi Odoo possède un inventaire :

Le suivi des stocks de Shopify est fonctionnel mais limité aux opérations multi-entrepôts et multicanaux. Le module d'inventaire d'Odoo gère : le suivi des lots et des numéros de série, la gestion des entrepôts multi-sites, les règles de réapprovisionnement automatisées, l'intégration de la fabrication (inventaire des composants de diminution des produits finis) et les opérations d'exécution basées sur des codes-barres. Shopify doit refléter la réalité des stocks d'Odoo, et non l'inverse.

Pourquoi Shopify est la couche commerciale :

Le paiement, le traitement des paiements, le calcul des frais d'expédition, la collecte des taxes et l'expérience client de Shopify sont les meilleurs de leur catégorie. Le commerce électronique B2C d'Odoo (site Web Odoo) est fonctionnel mais pas au niveau de Shopify pour le commerce DTC. L'architecture optimale conserve Shopify comme interface commerciale et Odoo comme épine dorsale opérationnelle.

---

Méthodes d'intégration : applications de connecteur et API personnalisée

Option 1 : applications de connecteur prédéfinies

Plusieurs applications de marché Shopify et Odoo offrent une intégration prédéfinie :

Les connecteurs prédéfinis fonctionnent bien pour : le catalogue de produits standard et la synchronisation des commandes pour des modèles commerciaux simples sans structures de variantes complexes, sans entrepôts multiples ou dépendances de fabrication.

Option 2 : Intégration personnalisée via des API

Pour les besoins commerciaux complexes, une intégration personnalisée utilisant l'API REST/GraphQL de Shopify et l'API JSON-RPC/REST d'Odoo offre le plus de contrôle et de fiabilité.

Architecture d'intégration personnalisée :

Shopify (Commerce Layer)
│
│ Webhooks (orders/create, orders/updated, refunds/create, inventory_levels/update)
│
▼
Integration Service (Node.js / Python middleware)
│
│ Event processing, transformation, error handling, retry logic
│
▼
Odoo (ERP Layer)
│
│ Odoo JSON-RPC API (sales orders, inventory, customers, accounting)
│
└── Inventory updates → Shopify Admin API

Pile technologique pour une intégration personnalisée :

• Middleware : Node.js (pour l'alignement de l'écosystème Shopify) ou Python (pour l'alignement de l'écosystème Odoo)
• File d'attente : Redis ou RabbitMQ pour un traitement fiable des événements
• Base de données : PostgreSQL pour l'état d'intégration, les clés d'idempotence, les journaux d'erreurs
• Hébergement : AWS Lambda ou similaire pour les gestionnaires de webhooks (évolue automatiquement avec les pics de trafic de Shopify)

---

Synchronisation des commandes : Shopify → Odoo

La synchronisation des commandes est le chemin d'intégration le plus critique. Chaque commande Shopify doit créer une commande de vente Odoo correspondante qui déclenche l'exécution et met à jour les dossiers financiers.

Configuration du webhook Shopify pour les événements de commande :

// Register webhooks via Shopify API
const webhooks = [
  {
    topic: 'orders/create',
    address: 'https://your-integration.com/webhooks/shopify/orders',
    format: 'json'
  },
  {
    topic: 'orders/updated',
    address: 'https://your-integration.com/webhooks/shopify/orders/updated',
    format: 'json'
  },
  {
    topic: 'orders/fulfilled',
    address: 'https://your-integration.com/webhooks/shopify/orders/fulfilled',
    format: 'json'
  },
  {
    topic: 'refunds/create',
    address: 'https://your-integration.com/webhooks/shopify/refunds',
    format: 'json'
  }
];

Transformer une commande Shopify en commande de vente Odoo :

def shopify_order_to_odoo_sale_order(shopify_order: dict) -> dict:
    """Transform Shopify order payload to Odoo sale.order format"""

    # Find or create Odoo partner (customer)
    partner_id = find_or_create_odoo_partner(
        email=shopify_order['email'],
        name=shopify_order['customer']['first_name'] + ' ' + shopify_order['customer']['last_name'],
        phone=shopify_order['customer'].get('phone'),
        shipping_address=shopify_order['shipping_address']
    )

    # Map line items
    order_lines = []
    for item in shopify_order['line_items']:
        odoo_product_id = get_odoo_product_from_shopify_variant(
            item['variant_id']
        )
        order_lines.append({
            'product_id': odoo_product_id,
            'product_uom_qty': item['quantity'],
            'price_unit': float(item['price']),
            'name': item['name'],
            'shopify_line_id': item['id'],  # Custom field for traceability
        })

    # Add shipping as a service product line
    if float(shopify_order.get('shipping_lines', [{}])[0].get('price', 0)) > 0:
        order_lines.append({
            'product_id': SHIPPING_PRODUCT_ID,  # Configured in settings
            'product_uom_qty': 1,
            'price_unit': float(shopify_order['shipping_lines'][0]['price']),
            'name': shopify_order['shipping_lines'][0]['title'],
        })

    return {
        'partner_id': partner_id,
        'order_line': [(0, 0, line) for line in order_lines],
        'shopify_order_id': shopify_order['id'],  # Custom field
        'shopify_order_name': shopify_order['name'],  # e.g., #1001
        'note': shopify_order.get('note', ''),
        'state': 'sale',  # Confirm order automatically
    }

Gestion de l'idempotence :

Shopify peut diffuser le même événement webhook plusieurs fois (tentatives réseau). Votre intégration doit gérer correctement les événements en double :

def process_shopify_order_webhook(payload: dict):
    shopify_order_id = str(payload['id'])

    # Check if already processed
    if OrderSyncLog.objects.filter(
        shopify_order_id=shopify_order_id,
        status='completed'
    ).exists():
        logger.info(f"Order {shopify_order_id} already processed, skipping")
        return

    # Process and log
    try:
        odoo_order_id = create_odoo_sale_order(payload)
        OrderSyncLog.objects.create(
            shopify_order_id=shopify_order_id,
            odoo_order_id=odoo_order_id,
            status='completed'
        )
    except Exception as e:
        OrderSyncLog.objects.create(
            shopify_order_id=shopify_order_id,
            status='failed',
            error=str(e)
        )
        raise

---

Synchronisation des stocks : Odoo → Shopify

Les niveaux de stock doivent refléter la réalité d'Odoo dans Shopify en temps réel (ou presque en temps réel) pour éviter les ventes excessives.

Synchronisation de l'inventaire basée sur des déclencheurs :

L'approche la plus fiable est la synchronisation basée sur les événements : lorsque les stocks changent dans Odoo (vente, reçu d'achat, achèvement de la fabrication, ajustement des stocks), Odoo transmet la quantité mise à jour à Shopify.

# In Odoo (using automated actions or override)
def _post_write_sync_to_shopify(self):
    """Called after inventory level changes in Odoo"""
    for move_line in self:
        product = move_line.product_id
        location = move_line.location_id

        if location.is_shopify_sync_location:
            shopify_variant_id = product.shopify_variant_id
            if shopify_variant_id:
                new_quantity = product.with_context(
                    location=location.id
                ).qty_available

                sync_inventory_to_shopify(
                    shopify_variant_id=shopify_variant_id,
                    quantity=int(new_quantity)
                )

def sync_inventory_to_shopify(shopify_variant_id: str, quantity: int):
    """Push inventory update to Shopify via Admin API"""
    inventory_item_id = get_inventory_item_id(shopify_variant_id)
    location_id = get_shopify_location_id()  # Primary Shopify location

    shopify.InventoryLevel.set(
        inventory_item_id=inventory_item_id,
        location_id=location_id,
        available=quantity
    )

Rapprochement d'inventaire planifié :

Même avec une synchronisation basée sur les événements, planifiez un rapprochement quotidien complet des stocks :

1. Exportez toutes les quantités de produits Odoo depuis l'emplacement de synchronisation Shopify désigné
2. Comparez avec les niveaux de stock actuels de Shopify
3. Mettez à jour tout écart (peut survenir en raison d'événements de synchronisation échoués ou d'ajustements manuels).
4. Consigner les résultats du rapprochement à des fins d'audit

Ce rapprochement empêche la dérive des stocks due à de petits échecs de synchronisation accumulés.

---

Synchronisation du catalogue de produits : Odoo → Shopify

Pour les entreprises qui gèrent des catalogues de produits dans Odoo (avec une tarification multidevise, des spécifications détaillées et des matrices de variantes complexes), la synchronisation du catalogue avec Shopify élimine la double saisie manuelle.

Architecture de cartographie des produits :

Odoo Product (product.template)
├── Shopify Product (via shopify_product_id field on Odoo template)
│
└── Odoo Product Variants (product.product)
    └── Shopify Variants (via shopify_variant_id field on Odoo product.product)

Que synchroniser d'Odoo vers Shopify :

• Nom du produit (description commerciale d'Odoo)
• Description du produit (description HTML longue)
• Images (images produit.modèle)
• Prix (en utilisant la liste de prix Shopify configurée)
• SKU (référence interne d'Odoo)
• Code-barres (EAN/UPC d'Odoo)
• Poids (pour le calcul de l'expédition)
• Statut actif/archivé (dépublier dans Shopify lorsque le produit Odoo est archivé)
• Inventaire (à partir de l'emplacement de synchronisation désigné)

Ce qu'il ne faut PAS synchroniser d'Odoo vers Shopify :

• Métadonnées SEO spécifiques à Shopify (balises de titre, méta descriptions — gérer dans Shopify)
• Balises de produits Shopify (gérer dans Shopify)
• Collections/catégories Shopify (gérer dans Shopify)
• Contenu spécifique à Shopify (sections de création de pages, descriptions riches formatées pour Shopify)

---

Gestion des données clients

Les clients qui existent à la fois dans Shopify (à partir de leur compte vitrine) et Odoo (en tant que contacts/partenaires) doivent être soigneusement fusionnés pour créer un seul profil unifié.

Stratégie de déduplication par courrier électronique :

def find_or_create_odoo_partner(email: str, name: str, **kwargs) -> int:
    """Find existing Odoo partner by email or create new one"""
    existing = Partner.search([
        ('email', '=', email)
    ], limit=1)

    if existing:
        # Update with latest data from Shopify
        existing.write({
            'phone': kwargs.get('phone', existing.phone),
        })
        return existing.id
    else:
        # Create new partner
        partner = Partner.create({
            'name': name,
            'email': email,
            'phone': kwargs.get('phone'),
            'type': 'contact',
            'customer_rank': 1,
            'shopify_customer_id': kwargs.get('shopify_customer_id'),
        })
        return partner.id

Identifiants clients Shopify stockés dans Odoo :

Ajoutez un champ personnalisé shopify_customer_id au modèle res.partner d'Odoo. Cela permet une recherche bidirectionnelle : recherchez le partenaire Odoo à partir de Shopify ID, recherchez le client Shopify à partir du partenaire Odoo.

---

Boucle de réalisation : Odoo → Shopify

Lorsqu'Odoo traite une livraison (picking + validation), la commande est exécutée. Shopify doit être notifié à :

• Marquer la commande comme exécutée
• Envoyer l'email de confirmation d'expédition au client
• Enregistrez le numéro de suivi

def sync_fulfillment_to_shopify(odoo_picking: StockPicking):
    """Called after Odoo delivery is validated"""
    shopify_order_name = odoo_picking.sale_id.shopify_order_name
    tracking_number = odoo_picking.carrier_tracking_ref

    # Find Shopify order
    shopify_orders = shopify.Order.find(name=shopify_order_name)
    if not shopify_orders:
        return

    shopify_order = shopify_orders[0]

    # Create fulfillment in Shopify
    fulfillment = shopify.Fulfillment.create({
        'order_id': shopify_order.id,
        'tracking_number': tracking_number,
        'tracking_company': odoo_picking.carrier_id.name,
        'notify_customer': True,  # Sends Shopify's shipping email
        'line_items': [
            {'id': line.shopify_line_id}
            for line in odoo_picking.sale_id.order_line
            if line.shopify_line_id
        ]
    })

---

Intégration comptable : Shopify Sales → Odoo Financials

Chaque vente Shopify doit éventuellement apparaître dans le module de comptabilité d'Odoo en tant qu'entrée de vente publiée.

Approche d'intégration pour la comptabilité :

Option 1 — Comptabilité au niveau de la commande : chaque commande Shopify crée une facture Odoo (ou la commande de vente Odoo génère une facture une fois exécutée). Les paiements enregistrés dans Shopify déclenchent l'enregistrement des paiements dans Odoo.

Option 2 — Comptabilité au niveau des règlements : les règlements Shopify Payments (dépôts bancaires quotidiens ou hebdomadaires) sont enregistrés dans Odoo sous forme d'écritures de journal qui se rapprochent des transactions bancaires. Ceci est plus simple à maintenir mais fournit une comptabilité moins granulaire.

Pour la plupart des commerçants de taille intermédiaire, la comptabilité au niveau du règlement (option 2) est suffisante et nettement moins complexe à mettre en œuvre et à maintenir.

Données de paiement Shopify → Entrée de journal Odoo :

def process_shopify_payout(payout_data: dict):
    """Create Odoo journal entry for Shopify Payments payout"""
    journal = ShopifyJournal.get_or_create()  # Shopify clearing account

    entry = AccountMove.create({
        'journal_id': journal.id,
        'date': payout_data['date'],
        'ref': f"Shopify Payout {payout_data['id']}",
        'line_ids': [
            (0, 0, {
                'account_id': SHOPIFY_CLEARING_ACCOUNT_ID,
                'credit': payout_data['amount'],
                'name': f"Shopify sales - {payout_data['period']}",
            }),
            (0, 0, {
                'account_id': SHOPIFY_FEES_ACCOUNT_ID,
                'debit': payout_data['fees'],
                'name': 'Shopify Payments fees',
            }),
            (0, 0, {
                'account_id': BANK_ACCOUNT_ID,
                'debit': payout_data['amount'] - payout_data['fees'],
                'name': f"Bank deposit - Shopify payout {payout_data['id']}",
            }),
        ]
    })
    entry.action_post()

---

Questions fréquemment posées

Combien de temps faut-il pour mettre en œuvre une intégration Shopify-Odoo ?

Une intégration de base (synchronisation des commandes, synchronisation des stocks, synchronisation des clients) à l'aide d'un connecteur prédéfini prend 2 à 4 semaines, y compris la configuration, les tests et la migration des données. Une intégration personnalisée couvrant le cycle de vie complet (commandes, inventaire, synchronisation des exécutions, retours, comptabilité) prend 8 à 16 semaines en fonction de la complexité de l'entreprise. Les scénarios complexes – Odoo multi-entrepôt, fabrication, multi-devises, multi-sociétés – ajoutent 4 à 8 semaines supplémentaires. Budget pour la maintenance continue : les intégrations nécessitent des mises à jour lorsque Shopify ou Odoo publient des changements d'API.

Dois-je gérer les produits dans Shopify ou Odoo ?

Pour les catalogues de produits simples : gérez dans Shopify et mettez à jour manuellement Odoo à des fins de fabrication/approvisionnement. Pour les catalogues complexes (nombreuses variantes, tarification multi-devises, spécifications techniques, nomenclatures de fabrication) : gérez dans Odoo et synchronisez avec Shopify. Le facteur critique est l’endroit où travaille réellement votre équipe produit. Si votre équipe de marchandisage vit dans Shopify, les forcer à travailler dans Odoo crée des frictions. Si votre équipe opérationnelle gère des produits dans Odoo pour la fabrication et l'approvisionnement, la synchronisation Shopify est la bonne approche.

Qu'arrive-t-il aux commandes Shopify existantes une fois l'intégration mise en ligne ?

Les commandes historiques n'ont pas besoin de migrer vers Odoo. L'intégration traite les nouvelles commandes à partir de la date de mise en service. Pour les données historiques (enregistrements clients, catalogue de produits, références d'inventaire), effectuez une migration de données unique avant la mise en ligne de l'intégration : importez les données clients historiques dans Odoo, importez le catalogue de produits et définissez les références d'inventaire dans Odoo pour qu'elles correspondent aux quantités Shopify actuelles.

Comment gérer les commandes Shopify avec des produits qui n'existent pas dans Odoo ?

Ce cas limite brise les intégrations naïves. Créez une solution de secours : lorsqu'une commande Shopify contient un identifiant de variante qui ne correspond pas à un produit Odoo, créez la commande dans Odoo avec un produit fictif "Produit inconnu" et alertez votre équipe d'intégration. Définissez une file d'attente d'erreurs avec notification : le personnel des opérations examine les produits non mappés, crée le produit Odoo et retraite la commande ayant échoué. Ceci est préférable à un échec silencieux ou au blocage de toutes les commandes en attendant un correctif de mappage.

Cette intégration peut-elle prendre en charge plusieurs boutiques Shopify (par exemple, différentes boutiques du marché) ?

Oui, mais avec une complexité supplémentaire. Chaque boutique Shopify est une connexion API distincte. Une instance Odoo peut recevoir des commandes de plusieurs magasins Shopify, la source du magasin étant suivie via un champ personnalisé. L'allocation des stocks entre les magasins nécessite une logique supplémentaire : soit un pool d'inventaire partagé (Odoo répartit entre les magasins en fonction de la demande de commande), soit un inventaire séparé par emplacement (chaque magasin a un emplacement Odoo désigné). L'intégration multi-magasins double la portée des tests et la charge de maintenance continue.

---

Prochaines étapes

Une intégration Shopify-Odoo bien mise en œuvre transforme l'efficacité opérationnelle : en éliminant la saisie manuelle des données, en empêchant la survente, en permettant des rapports sophistiqués et en connectant les ventes de commerce électronique aux processus de fabrication, d'approvisionnement et financiers.

ECOSIRE crée des Shopify et des intégrations Odoo ERP pour les commerçants de taille moyenne, couvrant la conception de l'architecture, le développement personnalisé, la migration des données, les tests et l'assistance continue. Notre équipe d'intégration a mis en œuvre des connexions Shopify-Odoo pour plus de 30 commerçants dans diverses catégories de produits.

Contactez notre équipe d'intégration pour concevoir votre architecture d'intégration Shopify-Odoo.