Shopify ERP-Integration: Technischer Leitfaden für DACH-Händler

Morgens um 7:14 Uhr zeigt Ihr ERP 38 Stück — Shopify zeigt 51. Um 7:42 Uhr bestellt ein Kunde 45 Stück. Shopify nimmt die Bestellung an. Ihr Lager kann sie nicht erfüllen. Was folgt: eine Storno-Mail, ein verlorener Kunde und ein Support-Ticket, das niemand gebraucht hätte.

Das ist kein Ausnahmefall. Das ist der Alltag von Shopify-Händlern, deren ERP und Shop nicht sauber miteinander sprechen. Und je mehr Kanäle Sie bespielen — Shopify, Amazon, stationärer Handel — desto explosiver wird das Problem.

In diesem Guide zeige ich Ihnen den technischen Weg zu einer stabilen ERP-Integration: Welches System zu welchem Setup passt, wie die Webhook-Architektur aussieht, was die Shopify GraphQL Admin API 2026-01 Neues bringt — und welche konkreten Code-Muster sich in der Praxis bewährt haben.

Warum fehlende ERP-Integration so teuer ist

Ohne saubere Verbindung zwischen Shopify und Ihrem ERP entstehen drei Kostentreiber, die sich monatlich summieren:

Eine Custom-Integration für 300–600 € Hosting- und Wartungskosten pro Monat amortisiert sich bei 200+ Bestellungen monatlich bereits im ersten Quartal.

Die 3 Integrations-Ansätze im Vergleich

ERP-Systeme im DACH-Raum: Überblick 2026

Laut einer Marktanalyse von digitalsprung.de dominieren im deutschsprachigen Raum folgende Systeme:

Welche Daten werden synchronisiert?

Eine vollständige Integration umfasst fünf Datendomänen — die Synchronisationsrichtung ist dabei entscheidend:

Technische Architektur: Webhooks + Queue

Die robusteste Architektur kombiniert Event-Driven Webhooks mit einer Queue und einem täglichen Reconciliation-Job.

Warum Queue statt direkter Verarbeitung?

Shopify erwartet eine HTTP-200-Antwort innerhalb von 5 Sekunden. Dauert Ihre ERP-Verarbeitung länger, markiert Shopify den Webhook als fehlgeschlagen und wiederholt — bis zu 19 Mal über 48 Stunden. Ohne Queue landen Sie in einer Retry-Spirale.

import { Queue } from 'bullmq';
import { createHmac, timingSafeEqual } from 'crypto';
 
const orderQueue = new Queue('shopify-orders', {
  connection: { host: process.env.REDIS_HOST, port: 6379 }
});
 
// HMAC-Verifizierung — immer zuerst
function verifyWebhook(rawBody, hmacHeader) {
  const digest = createHmac('sha256', process.env.SHOPIFY_WEBHOOK_SECRET)
    .update(rawBody, 'utf8')
    .digest('base64');
  try {
    return timingSafeEqual(Buffer.from(digest), Buffer.from(hmacHeader));
  } catch {
    return false;
  }
}
 
app.post('/webhooks/orders/create', async (req, res) => {
  // 1. Authentizität prüfen
  if (!verifyWebhook(req.rawBody, req.headers['x-shopify-hmac-sha256'])) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
 
  // 2. Sofort in Queue — nicht inline verarbeiten
  await orderQueue.add('process-order', {
    orderId: req.body.id,
    orderName: req.body.name,
    payload: req.body,
    webhookId: req.headers['x-shopify-webhook-id'],
  }, {
    attempts: 5,
    backoff: { type: 'exponential', delay: 5000 },
  });
 
  // 3. Sofort 200 zurückgeben
  res.status(200).send('OK');
});

Idempotenz: Doppelte Verarbeitung verhindern

Shopify kann denselben Webhook mehrfach senden. Ohne Idempotenz buchen Sie Bestellungen doppelt ins ERP.

// In Produktion: Redis SETNX statt Map
const processed = new Map();
 
async function handleIdempotent(webhookId, topic, handler) {
  const key = `${topic}:${webhookId}`;
  if (processed.has(key)) {
    return { skipped: true };
  }
  processed.set(key, Date.now());
  try {
    return await handler();
  } catch (err) {
    processed.delete(key); // Retry ermöglichen
    throw err;
  }
}

Bestandssync: Absolut statt relativ

# Admin API 2026-01: Bestand absolut setzen
mutation inventorySetQuantities($input: InventorySetQuantitiesInput!) {
  inventorySetQuantities(input: $input) {
    inventoryAdjustmentGroup {
      reason
      changes {
        name
        delta
        quantityAfterChange
      }
    }
    userErrors {
      field
      message
      code
    }
  }
}

// Absolute Werte — nie relative Deltas verwenden
async function syncStock(sku, erpQty, locationId) {
  const variables = {
    input: {
      reason: 'correction',
      referenceDocumentUri: `erp://sync/${Date.now()}`,
      quantities: [{
        inventoryItemId: await resolveInventoryItemId(sku),
        locationId,
        quantity: erpQty, // Absoluter Wert aus ERP
      }],
    },
  };
  return shopifyGraphQL(INVENTORY_SET_MUTATION, variables);
}

Fulfillment zurückmelden

Wenn das WMS den Versand bucht, muss Shopify die Tracking-Nummer erhalten:

mutation fulfillmentCreateV2($fulfillment: FulfillmentV2Input!) {
  fulfillmentCreateV2(fulfillment: $fulfillment) {
    fulfillment {
      id
      status
      trackingInfo {
        number
        url
        company
      }
    }
    userErrors {
      field
      message
    }
  }
}

async function pushFulfillment(fulfillmentOrderId, tracking) {
  return shopifyGraphQL(FULFILLMENT_CREATE_MUTATION, {
    fulfillment: {
      lineItemsByFulfillmentOrder: [{ fulfillmentOrderId }],
      trackingInfo: {
        number: tracking.trackingNumber,
        url: tracking.trackingUrl,
        company: tracking.carrier, // z.B. "DHL", "DPD", "GLS"
      },
      notifyCustomer: true,
    },
  });
}

Admin API 2026-01: Was ist neu?

Die Admin API Version 2026-01 bringt für ERP-Integrationen relevante Änderungen:

Für Bulk-Preisänderungen oder Massenbestandsupdates lohnt sich jetzt der Wechsel auf bulkOperationRunMutation:

# Bulk-Operation: Tausende SKUs in einem Job
mutation {
  bulkOperationRunMutation(
    mutation: """
      mutation inventorySet($input: InventorySetQuantitiesInput!) {
        inventorySetQuantities(input: $input) {
          inventoryAdjustmentGroup { reason }
          userErrors { field message }
        }
      }
    """,
    stagedUploadPath: "tmp/inventory-update.jsonl"
  ) {
    bulkOperation {
      id
      status
    }
    userErrors {
      field
      message
    }
  }
}

Webhook-Konfiguration und Retry-Verhalten

Pflicht-Webhooks für jede ERP-Integration

const WEBHOOKS = [
  { topic: 'ORDERS_CREATE',         handler: '/webhooks/orders/create' },
  { topic: 'ORDERS_UPDATED',        handler: '/webhooks/orders/updated' },
  { topic: 'ORDERS_CANCELLED',      handler: '/webhooks/orders/cancelled' },
  { topic: 'REFUNDS_CREATE',        handler: '/webhooks/refunds/create' },
  { topic: 'INVENTORY_LEVELS_UPDATE', handler: '/webhooks/inventory/update' },
  { topic: 'FULFILLMENTS_CREATE',   handler: '/webhooks/fulfillments/create' },
  // DSGVO-Pflicht für App-Store-Apps
  { topic: 'CUSTOMERS_DATA_REQUEST', handler: '/webhooks/gdpr/data-request' },
  { topic: 'CUSTOMERS_REDACT',      handler: '/webhooks/gdpr/redact' },
  { topic: 'SHOP_REDACT',           handler: '/webhooks/gdpr/shop-redact' },
];

Retry-Zeitplan (Shopify sendet bis zu 19 Mal)

Nach 48 Stunden ohne Erfolg wird der Webhook automatisch und still deaktiviert — kein Alert von Shopify. Deshalb ist eigenes Monitoring unverzichtbar.

Fehlerbehandlung und Monitoring

Dead-Letter-Queue

Wenn ein Job nach allen Retries fehlschlägt, gehört er in eine Dead-Letter-Queue — nicht ins Nirvana:

import { Queue, Worker } from 'bullmq';
 
const dlq = new Queue('shopify-orders-dlq');
 
const worker = new Worker('shopify-orders', async (job) => {
  await processOrderForERP(job.data);
}, {
  connection: { host: process.env.REDIS_HOST, port: 6379 },
  concurrency: 5,
});
 
worker.on('failed', async (job, err) => {
  if (job.attemptsMade >= job.opts.attempts) {
    await dlq.add('failed', {
      original: job.data,
      error: err.message,
      failedAt: new Date().toISOString(),
    });
    await alertCritical('ORDER_SYNC_FAILED', job.data.orderName, err.message);
  }
});

Tägliche Reconciliation (Safety Net)

async function dailyReconciliation() {
  const since = new Date(Date.now() - 86_400_000).toISOString();
 
  // Bestellungen der letzten 24h aus beiden Systemen
  const [shopifyOrders, erpOrders] = await Promise.all([
    fetchShopifyOrders(since),
    fetchERPOrders(since),
  ]);
 
  const erpNumbers = new Set(erpOrders.map(o => o.externalOrderId));
  const missing = shopifyOrders.filter(o => !erpNumbers.has(o.name));
 
  if (missing.length > 0) {
    // Fehlende Bestellungen mit hoher Priorität nachsynchronisieren
    for (const order of missing) {
      await orderQueue.add('reconcile', { payload: order }, { priority: 1 });
    }
    await alertHigh('RECONCILIATION_GAP', `${missing.length} Bestellungen nachsynchronisiert`);
  }
}
// Täglich um 03:00 Uhr per Cron

ERP-spezifische Hinweise (DACH)

JTL-Wawi

Seit Januar 2026 läuft die Shopify-Anbindung ausschließlich über den offiziellen JTL-Shopify-Connector im App Store. Custom Apps für JTL sind nicht mehr neu erstellbar. Das JTL-WMS mit Barcode-Scanner-Unterstützung ist Standard in vielen mittelständischen Lagern.

Xentral

Xentral bietet eine saubere REST-API mit guter Dokumentation. Stärke: native DATEV-Anbindung und GoBD-konforme Archivierung — wichtig für Steuerberater und Jahresabschluss.

WeClapp

Cloud-natives ERP mit gutem persönlichen Onboarding. API-Token-Authentifizierung. Für Händler, die ohne Agentur starten wollen, einer der zugänglichsten Einstiege.

Billbee

Eigener nativer Shopify-Connector bereits vorhanden. Custom-API-Nutzung lohnt sich nur, wenn Sie Bestellungen vor dem Import filtern oder anreichern müssen (z.B. B2B-Kunden anders behandeln).

SAP Business One

Seit Version 10: Service Layer REST API. Ältere Versionen: DI API (COM-basiert) oder Integration Framework. Wichtig: Sessions laufen nach 30 Minuten ab — automatisches Re-Login implementieren.

Kostenvergleich: 3-Jahres-Perspektive

Für einen Shop mit ca. 1.000 Bestellungen/Monat:

Die Custom-Lösung überholt den iPaaS-Ansatz bereits im zweiten Jahr. Bei stark wachsendem Volumen werden iPaaS-Kosten überproportional teurer (Preis pro Operation).

Checkliste vor dem Projektstart

1. Technische Voraussetzungen klären

   API-Dokumentation des ERPs beschaffen und prüfen (REST? Version? Auth-Verfahren?). Shopify Admin API Access Token mit korrekten Scopes einrichten: read_orders, write_inventory, read_products, write_fulfillments. Netzwerk-Konnektivität prüfen — On-Premise-ERPs brauchen oft VPN oder Tunnel.

2. Datenhoheit definieren

   Klären: Welches System ist Master für welche Daten? Das ERP ist typischerweise Product Master und Inventory Master. Shopify ist Order Master. Erstellen Sie ein Mapping-Dokument — welches Shopify-Feld fließt in welches ERP-Feld?

3. Testumgebung aufbauen

   Shopify Development Store einrichten. ERP-Sandbox oder Testsystem bereitstellen. Mindestens 20 Testbestellungen mit Sonderfällen vorbereiten: B2B, internationale Adressen, Teillieferungen, Retouren.

4. Monitoring konfigurieren

   Dashboard für Sync-Status einrichten (wie viele Jobs laufen, wie viele schlagen fehl?). Alerting für kritische Szenarien: fehlgeschlagene Bestellübertragung, Webhook-Endpunkt nicht erreichbar, Bestandssync-Verzögerung über 15 Minuten. Reconciliation-Job planen.

5. Rollback-Plan definieren

   Wie schalten Sie bei einem Ausfall auf den manuellen Prozess zurück? Wer wird benachrichtigt? Was ist die maximale tolerierbare Ausfallzeit?

Fazit: Der richtige Ansatz für Ihre Situation

Eine ERP-Integration ist kein einmaliges Projekt — sie ist ein lebendes System, das mit Ihrem Business wächst. Die Entscheidung für den richtigen Ansatz hängt von drei Faktoren ab: Bestellvolumen, Systemkomplexität und langfristiger Kostenperspektive.

Standard-Connector (JTL, Synesty): Wenn Sie ein gängiges DACH-ERP haben, Standard-Prozesse leben und unter 500 Bestellungen/Tag bleiben.

Custom-Middleware: Wenn Sie komplexe Geschäftslogik haben, über 1.000 Bestellungen/Tag verarbeiten oder langfristig Kosten gegenüber iPaaS einsparen wollen.

Mein Rat: Starten Sie mit dem einfachsten Ansatz, der Ihre Anforderungen zu 80 % erfüllt — und bauen Sie gezielt aus, wenn Sie an die Grenzen stoßen.

Häufige Fragen

Weiterführende Artikel

• Shopify App entwickeln: Der ehrliche Leitfaden — Wenn die Integration eine eigene Custom App werden soll: OAuth, Tech-Stack, App Store Review
• Shopify Automatisierung: Custom-Prozesse — Queue-basierte Architekturen und Event-Driven Patterns im Detail
• Shopify Flow vs. Custom Automatisierung — Wann Flow reicht und wann Sie eine eigene Middleware brauchen