Shopify + Odoo ERP-Integration: Der vollständige Leitfaden

Mit zunehmender Größe der Shopify-Shops wird die Lücke zwischen dem, was Shopify nativ verarbeitet, und dem, was das Unternehmen tatsächlich für operative Exzellenz benötigt, zu einem erheblichen Hindernis. Bestandsverwaltung über mehrere Lager hinweg, Buchhaltung in mehreren Währungen, durch Shopify-Verkäufe ausgelöste Fertigungsaufträge, ausgefeiltes CRM mit vollständiger Kundenhistorie und automatisierte Lieferantennachfüllung – all dies erfordert ein ERP, und Odoo ist zunehmend das System der Wahl für mittelständische E-Commerce-Unternehmen.

Shopify + Odoo ist keine Plug-and-Play-Integration. Es erfordert sorgfältige Architekturentscheidungen darüber, welches System welche Daten besitzt, was in welche Richtung synchronisiert wird und wie Randfälle wie Teillieferungen, Retourenverarbeitung und Variantenzuordnung gehandhabt werden. Dieser Leitfaden deckt alles ab, von der Integrationsarchitektur bis hin zu spezifischen Implementierungsmustern.

Wichtige Erkenntnisse

• Odoo ist die Quelle der Wahrheit für Inventar, Kunden und Buchhaltung; Shopify ist die Quelle der Wahrheit für E-Commerce-Transaktionen
• Die bidirektionale Inventarsynchronisierung (Shopify → Odoo für Bestellungen, Odoo → Shopify für Lagerbestände) ist die zentrale Integrationsanforderung
• Die Produktkatalogverwaltung sollte in Odoo erfolgen und mit Shopify synchronisiert werden – nicht umgekehrt
• Kundendatensätze werden zwischen Systemen zusammengeführt, wobei E-Mail als eindeutige Kennung verwendet wird
• Bestelllebenszyklus: Shopify erstellt Bestellung → Odoo erhält Bestellung → Odoo erstellt Lieferung → Erfüllungsaktualisierungen Shopify
• Die Retourenabwicklung erfordert Koordination: Shopify leitet die Retoure ein → Odoo verarbeitet den Empfang → beide Systeme werden aktualisiert
• Die Webhook-API von Shopify bietet Bestellereignisse in Echtzeit. Odoo erhält diese über Connector-Middleware
• Es gibt direkte Odoo-Shopify-Konnektoren (Syncee, OdooConnector), aber benutzerdefinierte Integrationen über die REST-API bieten mehr Kontrolle

---

Die Integrationsarchitektur verstehen

Definieren Sie vor der Implementierung das maßgebliche System für jede Datendomäne:

Warum Odoo Inventar besitzt:

Die Bestandsverfolgung von Shopify ist funktionsfähig, aber für Multi-Warehouse- und Multi-Channel-Vorgänge eingeschränkt. Das Inventarmodul von Odoo übernimmt die Verfolgung von Chargen- und Seriennummern, die Lagerverwaltung an mehreren Standorten, automatisierte Nachschubregeln, die Fertigungsintegration (Abnahme des Komponentenbestands bei Fertigwaren) und barcodegesteuerte Erfüllungsvorgänge. Shopify muss die Bestandsrealität von Odoo widerspiegeln, nicht umgekehrt.

Warum Shopify die Handelsebene ist:

Shopifys Checkout, Zahlungsabwicklung, Versandkostenberechnung, Steuererhebung und Kundenerfahrung sind erstklassig. Odoos B2C-E-Commerce (Odoo-Website) ist funktionsfähig, aber nicht auf dem Niveau von Shopify für DTC-Commerce. Die optimale Architektur behält Shopify als Handelsschnittstelle und Odoo als operatives Rückgrat bei.

---

Integrationsmethoden: Connector-Apps vs. benutzerdefinierte API

Option 1: Vorgefertigte Connector-Apps

Mehrere Shopify- und Odoo-Marktplatz-Apps bieten vorgefertigte Integration:

Vorgefertigte Konnektoren eignen sich gut für: Standardproduktkatalog- und Bestellsynchronisierung für einfache Geschäftsmodelle ohne komplexe Variantenstrukturen, mehrere Lager oder Fertigungsabhängigkeiten.

Option 2: Benutzerdefinierte Integration über APIs

Für komplexe Geschäftsanforderungen bietet eine benutzerdefinierte Integration mit der REST/GraphQL-API von Shopify und der JSON-RPC/REST-API von Odoo die größte Kontrolle und Zuverlässigkeit.

Benutzerdefinierte Integrationsarchitektur:

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

Technologie-Stack für benutzerdefinierte Integration:

• Middleware: Node.js (für die Ausrichtung des Shopify-Ökosystems) oder Python (für die Ausrichtung des Odoo-Ökosystems)
• Warteschlange: Redis oder RabbitMQ für zuverlässige Ereignisverarbeitung
• Datenbank: PostgreSQL für Integrationsstatus, Idempotenzschlüssel, Fehlerprotokolle
• Hosting: AWS Lambda oder ähnliches für Webhook-Handler (skaliert automatisch mit Shopify-Verkehrsspitzen)

---

Bestellsynchronisierung: Shopify → Odoo

Die Auftragssynchronisierung ist der wichtigste Integrationspfad. Für jede Shopify-Bestellung muss ein entsprechender Odoo-Verkaufsauftrag erstellt werden, der die Erfüllung auslöst und die Finanzunterlagen aktualisiert.

Shopify-Webhook-Einrichtung für Bestellereignisse:

// 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'
  }
];

Umwandeln einer Shopify-Bestellung in eine Odoo-Verkaufsbestellung:

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
    }

Idempotenzbehandlung:

Shopify kann dasselbe Webhook-Ereignis mehrmals übermitteln (Netzwerk-Wiederholungsversuche). Ihre Integration muss doppelte Ereignisse ordnungsgemäß verarbeiten:

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

---

Inventarsynchronisierung: Odoo → Shopify

Die Lagerbestände müssen die Realität von Odoo in Shopify in Echtzeit (oder nahezu in Echtzeit) widerspiegeln, um Überverkäufe zu verhindern.

Triggerbasierte Inventarsynchronisierung:

Der zuverlässigste Ansatz ist die ereignisgesteuerte Synchronisierung: Wenn sich der Bestand in Odoo ändert (Verkauf, Kaufbeleg, Fertigungsabschluss, Bestandsanpassung), überträgt Odoo die aktualisierte Menge an 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
    )

Geplanter Bestandsabgleich:

Planen Sie auch bei ereignisgesteuerter Synchronisierung einen täglichen vollständigen Bestandsabgleich:

1. Exportieren Sie alle Odoo-Produktmengen vom angegebenen Shopify-Sync-Standort
2. Vergleichen Sie mit den aktuellen Lagerbeständen von Shopify
3. Aktualisieren Sie alle Unstimmigkeiten (kann aufgrund fehlgeschlagener Synchronisierungsereignisse oder manueller Anpassungen auftreten).
4. Protokollieren Sie die Abgleichsergebnisse zu Prüfzwecken

Dieser Abgleich verhindert eine Bestandsabweichung aufgrund angehäufter kleiner Synchronisierungsfehler.

---

Produktkatalog-Synchronisierung: Odoo → Shopify

Für Unternehmen, die Produktkataloge in Odoo verwalten (mit Preisen in mehreren Währungen, detaillierten Spezifikationen und komplexen Variantenmatrizen), eliminiert die Synchronisierung des Katalogs mit Shopify manuelle Doppeleingaben.

Produktzuordnungsarchitektur:

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)

Was von Odoo mit Shopify synchronisiert werden soll:

• Produktname (Verkaufsbeschreibung von Odoo)
• Produktbeschreibung (lange HTML-Beschreibung)
• Bilder (product.template-Bilder)
• Preis (unter Verwendung der konfigurierten Shopify-Preisliste)
• SKU (Odoos interne Referenz)
• Barcode (EAN/UPC von Odoo)
• Gewicht (zur Versandberechnung)
• Status „Aktiv/Archiviert“ (Veröffentlichung in Shopify aufheben, wenn das Odoo-Produkt archiviert wird)
• Inventar (vom angegebenen Synchronisierungsort)

Was Sie NICHT von Odoo mit Shopify synchronisieren sollten:

• Shopify-spezifische SEO-Metadaten (Titel-Tags, Meta-Beschreibungen – in Shopify verwalten)
• Shopify-Produkt-Tags (in Shopify verwalten)
• Shopify-Sammlungen/Kategorien (in Shopify verwalten)
• Shopify-spezifische Inhalte (Seitenerstellungsabschnitte, ausführliche, für Shopify formatierte Beschreibungen)

---

Kundendatenmanagement

Kunden, die sowohl in Shopify (von ihrem Storefront-Konto) als auch in Odoo (als Kontakte/Partner) vorhanden sind, müssen sorgfältig zusammengeführt werden, um ein einziges einheitliches Profil zu erstellen.

Deduplizierungsstrategie per E-Mail:

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

In Odoo gespeicherte Shopify-Kunden-IDs:

Fügen Sie ein benutzerdefiniertes Feld shopify_customer_id zum res.partner-Modell von Odoo hinzu. Dies ermöglicht eine bidirektionale Suche: Odoo-Partner über Shopify-ID finden, Shopify-Kunden über Odoo-Partner finden.

---

Erfüllungsschleife: Odoo → Shopify

Wenn Odoo eine Lieferung verarbeitet (Kommissionierung + Validierung), wird die Bestellung ausgeführt. Shopify muss benachrichtigt werden an:

• Markieren Sie die Bestellung als erfüllt
• Senden Sie die Versandbestätigungs-E-Mail an den Kunden
• Notieren Sie die Sendungsverfolgungsnummer

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
        ]
    })

---

Buchhaltungsintegration: Shopify Sales → Odoo Financials

Jeder Shopify-Verkauf muss irgendwann im Buchhaltungsmodul von Odoo als gebuchter Verkaufseintrag erscheinen.

Integrationsansatz für die Buchhaltung:

Option 1 – Buchhaltung auf Bestellebene: Jede Shopify-Bestellung erstellt eine Odoo-Rechnung (oder der Odoo-Verkaufsauftrag generiert bei Erfüllung eine Rechnung). In Shopify erfasste Zahlungen lösen eine Zahlungsregistrierung in Odoo aus.

Option 2 – Abrechnung auf Abrechnungsebene: Shopify Payments-Abrechnungen (tägliche oder wöchentliche Bankeinzahlungen) werden in Odoo als Journaleinträge erfasst, die mit Banktransaktionen abgeglichen werden. Dies ist einfacher zu pflegen, bietet aber eine weniger detaillierte Buchhaltung.

Für die meisten mittelständischen Händler ist die Abrechnung auf Abrechnungsebene (Option 2) ausreichend und deutlich weniger komplex in der Implementierung und Wartung.

Shopify-Auszahlungsdaten → Odoo-Journaleintrag:

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()

---

Häufig gestellte Fragen

Wie lange dauert die Implementierung einer Shopify-Odoo-Integration?

Eine grundlegende Integration (Auftragssynchronisierung, Bestandssynchronisierung, Kundensynchronisierung) mithilfe eines vorgefertigten Connectors dauert einschließlich Konfiguration, Tests und Datenmigration zwei bis vier Wochen. Eine benutzerdefinierte Integration, die den gesamten Lebenszyklus abdeckt (Bestellungen, Lagerbestand, Erfüllungssynchronisierung, Retouren, Buchhaltung), dauert je nach Geschäftskomplexität 8–16 Wochen. Komplexe Szenarien – Multi-Lager, Fertigung, Multi-Währung, Multi-Unternehmen Odoo – fügen 4–8 zusätzliche Wochen hinzu. Budget für laufende Wartung: Integrationen erfordern Aktualisierungen, wenn sich die Release-API von Shopify oder Odoo ändert.

Soll ich Produkte in Shopify oder Odoo verwalten?

Für einfache Produktkataloge: Verwalten Sie sie in Shopify und aktualisieren Sie Odoo manuell für Fertigungs-/Beschaffungszwecke. Für komplexe Kataloge (viele Varianten, Preise in mehreren Währungen, technische Spezifikationen, Fertigungsstücklisten): Verwalten Sie sie in Odoo und synchronisieren Sie sie mit Shopify. Der entscheidende Faktor ist, wo Ihr Produktteam tatsächlich arbeitet. Wenn Ihr Merchandising-Team in Shopify lebt, führt es zu Reibungen, wenn Sie es zwingen, in Odoo zu arbeiten. Wenn Ihr Betriebsteam Produkte für die Herstellung und Beschaffung in Odoo verwaltet, ist Shopify Sync der richtige Ansatz.

Was passiert mit bestehenden Shopify-Bestellungen, wenn die Integration live geht?

Historische Bestellungen müssen nicht nach Odoo migriert werden. Die Integration verarbeitet neue Bestellungen ab dem Go-Live-Datum. Führen Sie für historische Daten (Kundendatensätze, Produktkatalog, Bestandsbasislinien) eine einmalige Datenmigration durch, bevor die Integration live geht: Importieren Sie historische Kundendaten in Odoo, importieren Sie den Produktkatalog und legen Sie in Odoo Bestandsbasislinien fest, die mit den aktuellen Shopify-Mengen übereinstimmen.

Wie gehe ich mit Shopify-Bestellungen mit Produkten um, die in Odoo nicht vorhanden sind?

Dieser Randfall bricht naive Integrationen. Erstellen Sie einen Fallback: Wenn eine Shopify-Bestellung eine Varianten-ID enthält, die keinem Odoo-Produkt zugeordnet werden kann, erstellen Sie die Bestellung in Odoo mit einem Platzhalter „Unbekanntes Produkt“-Produkt und benachrichtigen Sie Ihr Integrationsteam. Definieren Sie eine Fehlerwarteschlange mit Benachrichtigung: Betriebsmitarbeiter überprüfen nicht zugeordnete Produkte, erstellen das Odoo-Produkt und verarbeiten die fehlgeschlagene Bestellung erneut. Dies ist einem stillen Fehler oder dem Blockieren aller Bestellungen vorzuziehen, während auf eine Zuordnungskorrektur gewartet wird.

Kann diese Integration mehrere Shopify-Shops unterstützen (z. B. verschiedene Marktshops)?

Ja, aber mit zusätzlicher Komplexität. Jeder Shopify-Shop ist eine separate API-Verbindung. Eine Odoo-Instanz kann Bestellungen von mehreren Shopify-Shops empfangen, wobei die Shop-Quelle über ein benutzerdefiniertes Feld verfolgt wird. Die Bestandszuordnung zwischen Filialen erfordert zusätzliche Logik: entweder ein gemeinsamer Bestandspool (Odoo ordnet die Filialen auf der Grundlage der Bestellnachfrage zu) oder ein standortgetrennter Bestand (jede Filiale verfügt über einen bestimmten Odoo-Standort). Die Multi-Store-Integration verdoppelt den Testumfang und den laufenden Wartungsaufwand.

---

Nächste Schritte

Eine gut implementierte Shopify-Odoo-Integration verändert die betriebliche Effizienz: Sie eliminiert die manuelle Dateneingabe, verhindert Überverkäufe, ermöglicht anspruchsvolle Berichte und verbindet E-Commerce-Verkäufe mit Fertigungs-, Beschaffungs- und Finanzprozessen.

ECOSIRE erstellt Shopify und Odoo ERP-Integrationen für mittelständische Händler – einschließlich Architekturdesign, kundenspezifischer Entwicklung, Datenmigration, Tests und fortlaufendem Support. Unser Integrationsteam hat Shopify-Odoo-Verbindungen für über 30 Händler in verschiedenen Produktkategorien implementiert.

Kontaktieren Sie unser Integrationsteam, um Ihre Shopify-Odoo-Integrationsarchitektur zu entwerfen.