DEV Community

Cover image for Magento 2 API nutzen: E-Commerce Integration Leitfaden (2026)
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

Magento 2 API nutzen: E-Commerce Integration Leitfaden (2026)

#api #backend #php #tutorial

TL;DR

Die Magento 2 (Adobe Commerce) API ermöglicht Entwicklern die programmatische Integration mit E-Commerce-Shops. Sie verwendet REST-, SOAP- und GraphQL-Endpunkte mit OAuth 1.0a und tokenbasierter Authentifizierung und bietet Zugriff auf Produkte, Bestellungen, Kunden, Inventar und mehr, mit konfigurierbaren Ratenlimits. Dieser Leitfaden behandelt die Authentifizierungseinrichtung, CRUD-Operationen, Webhooks, benutzerdefinierte Endpunkte und Integrationsstrategien für die Produktion.

Teste Apidog noch heute

Einführung

Adobe Commerce (Magento) betreibt über 250.000 E-Commerce-Shops mit einem jährlichen Bruttowarenwert von über 155 Milliarden US-Dollar. Für Entwickler, die E-Commerce-Integrationen, ERP-Konnektoren oder mobile Apps erstellen, ist die Magento API-Integration unerlässlich, um diesen riesigen Händlerstamm zu erreichen.

Händler, die mehrere Vertriebskanäle verwalten, verlieren wöchentlich 20-30 Stunden durch manuelle Dateneingaben zwischen Magento und anderen Systemen. Eine solide Magento API-Integration automatisiert die Produktsynchronisation, Auftragsabwicklung, Bestandsaktualisierungen und das Kundenbeziehungsmanagement.

In diesem Leitfaden lernst du, wie du eine vollständige Magento 2 API-Integration umsetzt: Authentifizierung (OAuth 1.0a, Token), Nutzung der REST/SOAP/GraphQL-Endpunkte, Verwaltung von Produkten und Bestellungen, Webhooks, Entwicklung eigener APIs und produktionsreife Deployment-Strategien.

💡 Tipp: Apidog vereinfacht das Testen der API-Integration. Teste deine Magento-Endpunkte, validiere Authentifizierungsabläufe, prüfe API-Antworten und debugge Integrationsprobleme in einem Arbeitsbereich. Importiere API-Spezifikationen, modelliere Antworten und teile Testszenarien mit deinem Team.

Was ist die Magento 2 API?

Magento 2 bietet drei API-Typen für den Zugriff auf E-Commerce-Daten:

  • REST API: JSON-basiert für Web- und mobile Anwendungen
  • SOAP API: XML-basiert für Unternehmensintegrationen
  • GraphQL: Abfrage-basiert für effiziente Frontend-Anwendungen

Du kannst mit der API folgende Ressourcen verwalten:

  • Produkte, Kategorien und Inventar
  • Bestellungen, Rechnungen und Lieferungen
  • Kunden und Kundengruppen
  • Warenkorb und Kasse
  • Werbeaktionen und Preisregeln
  • CMS-Seiten und -Blöcke
  • Shop-Konfiguration

Hauptfunktionen

Funktion Beschreibung
Mehrere Protokolle REST, SOAP, GraphQL
OAuth 1.0a Sicherer Zugriff von Drittanbietern
Token-Authentifizierung Admin- und Integrationstoken
Webhooks Asynchrone Operationen über Warteschlangen
Ratenbegrenzung Pro Installation konfigurierbar
Benutzerdefinierte Endpunkte Eigene APIs erweiterbar
Multi-Store Eine API, mehrere Store-Ansichten

API-Vergleich

API-Typ Protokoll Anwendungsfall
REST JSON Mobile Apps, Integrationen
SOAP XML Unternehmenssysteme (SAP, Oracle)
GraphQL GraphQL Storefront, PWA

Magento-Versionen

Version Status Ende des Supports
Magento 2.4.x Aktuell Aktiv
Adobe Commerce 2.4.x Aktuell Aktiv
Magento 1.x EOL Juni 2020 (Nicht verwenden)

Erste Schritte: Authentifizierung einrichten

Schritt 1: Admin-Konto oder Integration erstellen

  1. Im Magento Admin Panel anmelden
  2. Navigiere zu System > Berechtigungen > Alle Benutzer und erstelle einen Admin-Benutzer (für Admin-Token)
  3. Alternativ: System > Erweiterungen > Integrationen und neue Integration erstellen (für OAuth)

Schritt 2: Authentifizierungsmethode wählen

Methode Am besten geeignet für Token-Lebensdauer
Admin-Token Interne Integrationen Konfigurierbar (Standard: 4h)
Integrationstoken Drittanbieter-Apps Bis zum Widerruf
OAuth 1.0a Öffentliche Marktplatz-Apps Bis zum Widerruf
Kunden-Token Kundenorientierte Apps Konfigurierbar

Schritt 3: Admin-Token abrufen (einfachste Methode)

Admin-Token per REST-Endpoint generieren:

const MAGENTO_BASE_URL = process.env.MAGENTO_BASE_URL;
const MAGENTO_ADMIN_USERNAME = process.env.MAGENTO_ADMIN_USERNAME;
const MAGENTO_ADMIN_PASSWORD = process.env.MAGENTO_ADMIN_PASSWORD;

const getAdminToken = async () => {
  const response = await fetch(`${MAGENTO_BASE_URL}/rest/V1/integration/admin/token`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      username: MAGENTO_ADMIN_USERNAME,
      password: MAGENTO_ADMIN_PASSWORD
    })
  });

  if (!response.ok) throw new Error('Invalid admin credentials');
  const token = await response.text();
  return token;
};

// Verwendung
const token = await getAdminToken();
console.log(`Admin token: ${token}`);
// Token sicher speichern
Enter fullscreen mode Exit fullscreen mode

Token-Speicherung (.env Beispiel):

# .env file
MAGENTO_BASE_URL="https://store.example.com"
MAGENTO_ADMIN_USERNAME="api_user"
MAGENTO_ADMIN_PASSWORD="secure_password_here"
MAGENTO_ACCESS_TOKEN="obtained_via_auth"
Enter fullscreen mode Exit fullscreen mode

Schritt 4: Integration erstellen (für Drittanbieter empfohlen)

  1. Navigiere zu System > Erweiterungen > Integrationen
  2. Klicke auf Neue Integration hinzufügen
  3. Details ausfüllen:
  4. API-Berechtigungen festlegen (Produkte, Bestellungen, Kunden, Inventar)
  5. Speichern und Aktivieren
  6. Zugriffstoken und Token Secret kopieren

Schritt 5: Kunden-Token abrufen

Für kundenorientierte Anwendungen:

const getCustomerToken = async (email, password) => {
  const response = await fetch(`${MAGENTO_BASE_URL}/rest/V1/integration/customer/token`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ username: email, password: password })
  });

  if (!response.ok) throw new Error('Invalid customer credentials');
  const token = await response.text();
  return token;
};

// Verwendung
const customerToken = await getCustomerToken('customer@example.com', 'password123');
Enter fullscreen mode Exit fullscreen mode

Schritt 6: Authentifizierte API-Aufrufe tätigen

Schreibe einen wiederverwendbaren API-Client:

const magentoRequest = async (endpoint, options = {}) => {
  const token = await getAdminToken();
  const response = await fetch(`${MAGENTO_BASE_URL}/rest${endpoint}`, {
    ...options,
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
      ...options.headers
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Magento API Error: ${error.message}`);
  }
  return response.json();
};

// Beispiel:
const products = await magentoRequest('/V1/products');
console.log(`Found ${products.items.length} products`);
Enter fullscreen mode Exit fullscreen mode

Produktverwaltung

Produkte abrufen

Mit Filtern Produkte abfragen:

const getProducts = async (filters = {}) => {
  const params = new URLSearchParams();

  if (filters.search) {
    params.append('searchCriteria[filterGroups][0][filters][0][field]', 'sku');
    params.append('searchCriteria[filterGroups][0][filters][0][value]', `%${filters.search}%`);
    params.append('searchCriteria[filterGroups][0][filters][0][conditionType]', 'like');
  }
  if (filters.priceFrom) {
    params.append('searchCriteria[filterGroups][1][filters][0][field]', 'price');
    params.append('searchCriteria[filterGroups][1][filters][0][value]', filters.priceFrom);
    params.append('searchCriteria[filterGroups][1][filters][0][conditionType]', 'gteq');
  }

  params.append('searchCriteria[pageSize]', filters.limit || 20);
  params.append('searchCriteria[currentPage]', filters.page || 1);

  const response = await magentoRequest(`/V1/products?${params.toString()}`);
  return response;
};

// Beispiel:
const products = await getProducts({ search: 'shirt', priceFrom: 20, limit: 50 });

products.items.forEach(product => {
  console.log(`${product.sku}: ${product.name} - $${product.price}`);
});
Enter fullscreen mode Exit fullscreen mode

Einzelnes Produkt abrufen 

const getProduct = async (sku) => {
  const response = await magentoRequest(`/V1/products/${sku}`);
  return response;
};

// Beispiel:
const product = await getProduct('TSHIRT-001');
console.log(`Name: ${product.name}`);
console.log(`Price: $${product.price}`);
console.log(`Stock: ${product.extension_attributes?.stock_item?.qty}`);
Enter fullscreen mode Exit fullscreen mode

Ein Produkt erstellen 

const createProduct = async (productData) => {
  const product = {
    product: {
      sku: productData.sku,
      name: productData.name,
      attribute_set_id: productData.attributeSetId || 4,
      type_id: 'simple',
      price: productData.price,
      status: productData.status || 1,
      visibility: productData.visibility || 4,
      weight: productData.weight || 1,
      extension_attributes: {
        stock_item: {
          qty: productData.qty || 0,
          is_in_stock: productData.qty > 0 ? true : false
        }
      },
      custom_attributes: [
        { attribute_code: 'description', value: productData.description },
        { attribute_code: 'short_description', value: productData.shortDescription },
        { attribute_code: 'color', value: productData.color },
        { attribute_code: 'size', value: productData.size }
      ]
    }
  };

  const response = await magentoRequest('/V1/products', {
    method: 'POST',
    body: JSON.stringify(product)
  });
  return response;
};

// Beispiel:
const newProduct = await createProduct({
  sku: 'TSHIRT-NEW-001',
  name: 'Premium Cotton T-Shirt',
  price: 29.99,
  qty: 100,
  description: 'High-quality cotton t-shirt',
  shortDescription: 'Premium cotton tee',
  color: 'Blue',
  size: 'M'
});
console.log(`Product created: ${newProduct.id}`);
Enter fullscreen mode Exit fullscreen mode

Ein Produkt aktualisieren 

const updateProduct = async (sku, updates) => {
  const product = { product: { sku: sku, ...updates } };

  const response = await magentoRequest(`/V1/products/${sku}`, {
    method: 'PUT',
    body: JSON.stringify(product)
  });
  return response;
};

// Beispiel – Preis und Lagerbestand aktualisieren
await updateProduct('TSHIRT-001', {
  price: 24.99,
  extension_attributes: {
    stock_item: {
      qty: 150,
      is_in_stock: true
    }
  }
});
Enter fullscreen mode Exit fullscreen mode

Ein Produkt löschen 

const deleteProduct = async (sku) => {
  await magentoRequest(`/V1/products/${sku}`, {
    method: 'DELETE'
  });
  console.log(`Product ${sku} deleted`);
};
Enter fullscreen mode Exit fullscreen mode

Produkttypen

Typ Beschreibung Anwendungsfall
Einfach Eine SKU, keine Varianten Standardprodukte
Konfigurierbar Übergeordnet mit Varianten Größen-/Farboptionen
Gruppiert Sammlung einfacher Produkte Produktbündel
Virtuell Nicht-physische Produkte Dienste, Downloads
Bündel Anpassbare Produktbündel Zusammenstellbare Kits
Herunterladbar Digitale Produkte E-Books, Software

Auftragsverwaltung

Bestellungen abrufen 

const getOrders = async (filters = {}) => {
  const params = new URLSearchParams();

  if (filters.status) {
    params.append('searchCriteria[filterGroups][0][filters][0][field]', 'status');
    params.append('searchCriteria[filterGroups][0][filters][0][value]', filters.status);
    params.append('searchCriteria[filterGroups][0][filters][0][conditionType]', 'eq');
  }
  if (filters.dateFrom) {
    params.append('searchCriteria[filterGroups][1][filters][0][field]', 'created_at');
    params.append('searchCriteria[filterGroups][1][filters][0][value]', filters.dateFrom);
    params.append('searchCriteria[filterGroups][1][filters][0][conditionType]', 'gteq');
  }

  params.append('searchCriteria[pageSize]', filters.limit || 20);
  params.append('searchCriteria[currentPage]', filters.page || 1);

  const response = await magentoRequest(`/V1/orders?${params.toString()}`);
  return response;
};

// Beispiel – Offene Bestellungen der letzten 7 Tage:
const orders = await getOrders({
  status: 'pending',
  dateFrom: '2026-03-18 00:00:00',
  limit: 50
});

orders.items.forEach(order => {
  console.log(`Order #${order.increment_id}: ${order.customer_email} - $${order.grand_total}`);
});
Enter fullscreen mode Exit fullscreen mode

Einzelne Bestellung abrufen 

const getOrder = async (orderId) => {
  const response = await magentoRequest(`/V1/orders/${orderId}`);
  return response;
};

// Beispiel:
const order = await getOrder(12345);
console.log(`Order #${order.increment_id}`);
console.log(`Status: ${order.status}`);
console.log(`Total: $${order.grand_total}`);
order.items.forEach(item => {
  console.log(`  - ${item.name} x ${item.qty_ordered}`);
});
Enter fullscreen mode Exit fullscreen mode

Bestellstatus-Fluss 

pending → processing → complete
        → canceled
        → on_hold
        → payment_review
Enter fullscreen mode Exit fullscreen mode

Bestellstatus aktualisieren 

const updateOrderStatus = async (orderId, newStatus) => {
  // Direktes Status-Update benötigt Custom-Endpoint
  // Workflow nutzen:
  await magentoRequest(`/V1/orders/${orderId}/cancel`, { method: 'POST' });
  await magentoRequest(`/V1/orders/${orderId}/hold`, { method: 'POST' });
  await magentoRequest(`/V1/orders/${orderId}/unhold`, { method: 'POST' });
};
Enter fullscreen mode Exit fullscreen mode

Rechnung erstellen 

const createInvoice = async (orderId, items = [], notify = true, appendComment = false, comment = null) => {
  const invoice = {
    capture: true,
    last: true,
    items: items
  };
  if (comment) {
    invoice.comment = comment;
    invoice.notify_customer = notify ? 1 : 0;
    invoice.append_comment = appendComment ? 1 : 0;
  }
  const response = await magentoRequest(`/V1/order/${orderId}/invoice`, {
    method: 'POST',
    body: JSON.stringify(invoice)
  });
  return response;
};

// Beispiel – Vollständige Rechnung erzeugen:
const invoiceId = await createInvoice(12345, [], true, false, 'Danke für Ihre Bestellung!');
console.log(`Invoice created: ${invoiceId}`);
Enter fullscreen mode Exit fullscreen mode

Sendung erstellen 

const createShipment = async (orderId, items = [], notify = true, appendComment = false, comment = null, tracks = []) => {
  const shipment = {
    items: items,
    notify: notify ? 1 : 0,
    append_comment: appendComment ? 1 : 0,
    comment: comment,
    tracks: tracks
  };

  const response = await magentoRequest(`/V1/order/${orderId}/ship`, {
    method: 'POST',
    body: JSON.stringify(shipment)
  });
  return response;
};

// Beispiel – Versand mit Tracking:
const shipmentId = await createShipment(12345, [], true, false, 'Ihre Bestellung wurde versendet!', [
  {
    track_number: '1Z999AA10123456784',
    title: 'Tracking Number',
    carrier_code: 'ups'
  }
]);
console.log(`Shipment created: ${shipmentId}`);
Enter fullscreen mode Exit fullscreen mode

Kundenverwaltung

Kunden abrufen 

const getCustomers = async (filters = {}) => {
  const params = new URLSearchParams();

  if (filters.email) {
    params.append('searchCriteria[filterGroups][0][filters][0][field]', 'email');
    params.append('searchCriteria[filterGroups][0][filters][0][value]', filters.email);
    params.append('searchCriteria[filterGroups][0][filters][0][conditionType]', 'eq');
  }

  params.append('searchCriteria[pageSize]', filters.limit || 20);

  const response = await magentoRequest(`/V1/customers/search?${params.toString()}`);
  return response;
};

// Beispiel:
const customers = await getCustomers({ email: 'customer@example.com' });
customers.items.forEach(customer => {
  console.log(`${customer.firstname} ${customer.lastname} - ${customer.email}`);
});
Enter fullscreen mode Exit fullscreen mode

Einen Kunden erstellen 

const createCustomer = async (customerData) => {
  const customer = {
    customer: {
      websiteId: customerData.websiteId || 1,
      email: customerData.email,
      firstname: customerData.firstname,
      lastname: customerData.lastname,
      middlename: customerData.middlename || '',
      gender: customerData.gender || 0,
      store_id: customerData.storeId || 0,
      extension_attributes: {
        is_subscribed: customerData.subscribed || false
      }
    },
    password: customerData.password
  };

  const response = await magentoRequest('/V1/customers', {
    method: 'POST',
    body: JSON.stringify(customer)
  });
  return response;
};

// Beispiel:
const newCustomer = await createCustomer({
  email: 'newcustomer@example.com',
  firstname: 'John',
  lastname: 'Doe',
  password: 'SecurePass123!',
  subscribed: true
});
console.log(`Customer created: ID ${newCustomer.id}`);
Enter fullscreen mode Exit fullscreen mode

Bestandsverwaltung (MSI)

Lagerstatus abrufen 

const getStockStatus = async (sku) => {
  const response = await magentoRequest(`/V1/products/${sku}/stockItems/1`);
  return response;
};

// Beispiel:
const stock = await getStockStatus('TSHIRT-001');
console.log(`Qty: ${stock.qty}`);
console.log(`In Stock: ${stock.is_in_stock}`);
console.log(`Min Qty: ${stock.min_qty}`);
Enter fullscreen mode Exit fullscreen mode

Bestand aktualisieren 

const updateStock = async (sku, qty, isInStock = null) => {
  const stockItem = {
    stockItem: {
      qty: qty,
      is_in_stock: isInStock !== null ? isInStock : qty > 0
    }
  };

  const response = await magentoRequest(`/V1/products/${sku}/stockItems/1`, {
    method: 'PUT',
    body: JSON.stringify(stockItem)
  });
  return response;
};

// Beispiel:
await updateStock('TSHIRT-001', 100, true);
Enter fullscreen mode Exit fullscreen mode

Webhooks und asynchrone Operationen

Webhooks einrichten

Magento hat keine nativen Webhooks. Alternativen:

// 1. Poll orders endpoint regelmäßig:
const pollNewOrders = async (lastOrderId) => {
  const orders = await getOrders({
    dateFrom: new Date().toISOString()
  });
  const newOrders = orders.items.filter(o => o.id > lastOrderId);
  return newOrders;
};

// 2. Adobe I/O Events (nur Adobe Commerce)
// Events über Adobe Developer Console konfigurieren

// 3. Eigenes Webhook-Modul entwickeln
// Siehe: https://devdocs.magento.com/guides/v2.4/extension-dev-guide/message-queues/message-queues.html
Enter fullscreen mode Exit fullscreen mode

Ratenbegrenzung

Ratenbegrenzungen verstehen

  • Standard: Keine Begrenzung (im Admin konfigurierbar)
  • Empfohlen: 100-1000 Anfragen/Minute

Konfiguriere im Admin unter Stores > Konfiguration > Dienste > Web API > Sicherheit

Implementierung der Ratenbegrenzungsbehandlung 

const makeRateLimitedRequest = async (endpoint, options = {}, maxRetries = 3) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await magentoRequest(endpoint, options);
      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};
Enter fullscreen mode Exit fullscreen mode

Checkliste für die Produktivbereitstellung

Vor Live-Schaltung:

  • [ ] Integrationstoken (nicht Admin-Anmeldeinformationen) in der Produktion verwenden
  • [ ] Token sicher speichern (verschlüsselte Datenbank)
  • [ ] Ratenbegrenzung und Anfragen-Warteschlangen implementieren
  • [ ] Umfassende Fehlerbehandlung hinzufügen
  • [ ] Protokollierung für alle API-Aufrufe einrichten
  • [ ] Webhook-Alternative erstellen (Polling oder Adobe I/O)
  • [ ] Mit Produktionsdatenvolumen testen
  • [ ] Wiederholungslogik für fehlgeschlagene Anfragen implementieren

Praxisbeispiele

ERP-Integration

  • Herausforderung: Manuelle Bestandsaktualisierungen zwischen ERP und Magento
  • Lösung: Bidirektionale API-Synchronisation alle 15 Minuten
  • Ergebnis: Echtzeit-Bestand, kein Überverkauf

Mobile App

  • Herausforderung: Native mobile Erfahrung erforderlich
  • Lösung: GraphQL API für Produktanzeige, REST für Checkout
  • Ergebnis: 40% Steigerung der mobilen Konversion

Fazit

Die Magento 2 API bietet umfassende E-Commerce-Funktionalität. Wichtig für die Praxis:

  • REST-, SOAP- und GraphQL-APIs verfügbar
  • Token-basierte Authentifizierung für Integrationen
  • Volle CRUD-Operationen für Produkte, Bestellungen, Kunden
  • MSI für erweiterte Bestandsverwaltung
  • Ratenbegrenzungen pro Installation konfigurierbar
  • Apidog optimiert API-Tests und Team-Kollaboration

FAQ-Bereich

Wie authentifiziere ich mich bei der Magento API?

Verwende einen Admin-Token für interne Integrationen oder erstelle eine Integration unter System > Erweiterungen für OAuth. Kunden-Token für kundenorientierte Apps.

Was ist der Unterschied zwischen REST und GraphQL in Magento?

REST bietet vollständige CRUD-Operationen. GraphQL ist für Frontend-Abfragen mit effizienter Datenabfrage optimiert.

Wie erstelle ich ein Produkt über die API?

POST an /V1/products mit Produktdaten, einschließlich SKU, Name, Preis und stock_item in den extension_attributes.

Kann ich Webhooks für neue Bestellungen erhalten?

Magento hat keine nativen Webhooks. Verwende Polling, Adobe I/O Events (Adobe Commerce) oder entwickle ein benutzerdefiniertes Modul.

Wie aktualisiere ich Bestandsmengen?

PUT an /V1/products/{sku}/stockItems/1 mit den Werten für qty und is_in_stock.

Top comments (0)