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

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.

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 nicht optional – sie ist unerlässlich, um diesen riesigen Händlerstamm zu erreichen.

Hier ist die Realität: 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.

Dieser Leitfaden führt Sie durch den vollständigen Magento 2 API-Integrationsprozess. Sie lernen OAuth 1.0a und Token-Authentifizierung, REST/SOAP/GraphQL-Endpunkte, Produkt- und Bestellverwaltung, Webhooks, die Entwicklung benutzerdefinierter APIs und Bereitstellungsstrategien für die Produktion kennen. Am Ende werden Sie eine produktionsreife Magento-Integration haben.

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

Die API verwaltet:

• 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

API-Vergleich

Magento-Versionen

Erste Schritte: Authentifizierung einrichten

Schritt 1: Admin-Konto oder Integration erstellen

Vor dem Zugriff auf die API:

1. Melden Sie sich im Magento Admin Panel an
2. Navigieren Sie zu System > Berechtigungen > Alle Benutzer
3. Admin-Benutzer erstellen (für Admin-Token) ODER
4. Navigieren Sie zu System > Erweiterungen > Integrationen
5. Neue Integration erstellen (für OAuth)

Schritt 2: Authentifizierungsmethode wählen

Schritt 3: Admin-Token abrufen (einfachste Methode)

Admin-Token für interne Integrationen 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');
  }

  // Response is a plain string (the token), not JSON
  const token = await response.text();
  return token;
};

// Usage
const token = await getAdminToken();
console.log(`Admin token: ${token}`);
// Store securely - use for subsequent API calls

Sicherheitshinweis: Token sicher speichern:

# .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"

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

Integration über das Admin Panel erstellen:

Gehen Sie zu System > Erweiterungen > Integrationen

Klicken Sie auf Neue Integration hinzufügen

Details ausfüllen:

• Name: „Meine Integration“
• E-Mail: ihre-email@beispiel.de
• Callback-URL: (für OAuth)
• Identitätslink-URL: (für OAuth)

API-Berechtigungen festlegen:

• Ressourcen: Erforderliche Berechtigungen auswählen
• Empfohlen: Produkte, Bestellungen, Kunden, Inventar

Klicken Sie auf Speichern

Klicken Sie auf Aktivieren bei der neuen Integration

Kopieren Sie den Zugriffstoken und das Token Secret

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;
};

// Usage
const customerToken = await getCustomerToken('customer@example.com', 'password123');

Schritt 6: Authentifizierte API-Aufrufe tätigen

Wiederverwendbaren API-Client erstellen:

const magentoRequest = async (endpoint, options = {}) => {
  const token = await getAdminToken(); // Or retrieve stored token

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

// Usage
const products = await magentoRequest('/V1/products');
console.log(`Found ${products.items.length} products`);

Produktverwaltung

Produkte abrufen

Produkte mit Filterung abrufen:

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

  // Build search criteria
  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;
};

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

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

Einzelnes Produkt abrufen

Produkt nach SKU abrufen:

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

// Usage
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}`);

Ein Produkt erstellen

Einfaches Produkt erstellen:

const createProduct = async (productData) => {
  const product = {
    product: {
      sku: productData.sku,
      name: productData.name,
      attribute_set_id: productData.attributeSetId || 4, // Default set
      type_id: 'simple',
      price: productData.price,
      status: productData.status || 1, // 1=enabled, 2=disabled
      visibility: productData.visibility || 4, // 4=Catalog & Search
      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;
};

// Usage
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}`);

Ein Produkt aktualisieren

Produktinformationen 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;
};

// Usage - Update price and stock
await updateProduct('TSHIRT-001', {
  price: 24.99,
  extension_attributes: {
    stock_item: {
      qty: 150,
      is_in_stock: true
    }
  }
});

Ein Produkt löschen

Produkt entfernen:

const deleteProduct = async (sku) => {
  await magentoRequest(`/V1/products/${sku}`, {
    method: 'DELETE'
  });

  console.log(`Product ${sku} deleted`);
};

Produkttypen

Auftragsverwaltung

Bestellungen abrufen

Bestellungen mit Filterung 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;
};

// Usage - Get pending orders from last 7 days
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}`);
});

Einzelne Bestellung abrufen

Bestellung nach ID abrufen:

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

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

Bestellstatus-Fluss

pending → processing → complete
        → canceled
        → on_hold
        → payment_review

Bestellstatus aktualisieren

Bestellstatus ändern:

const updateOrderStatus = async (orderId, newStatus) => {
  // Note: Direct status update requires custom endpoint
  // Use order management workflow instead:

  // For cancel:
  await magentoRequest(`/V1/orders/${orderId}/cancel`, {
    method: 'POST'
  });

  // For hold:
  await magentoRequest(`/V1/orders/${orderId}/hold`, {
    method: 'POST'
  });

  // For unhold:
  await magentoRequest(`/V1/orders/${orderId}/unhold`, {
    method: 'POST'
  });
};

Rechnung erstellen

Rechnung für Bestellung generieren:

const createInvoice = async (orderId, items = [], notify = true, appendComment = false, comment = null) => {
  const invoice = {
    capture: true, // true = capture payment
    last: true,
    items: items // Array of {order_item_id, qty}
  };

  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;
};

// Usage - Invoice and capture full order
const invoiceId = await createInvoice(12345, [], true, false, 'Thank you for your order!');
console.log(`Invoice created: ${invoiceId}`);

Sendung erstellen

Bestellung versenden:

const createShipment = async (orderId, items = [], notify = true, appendComment = false, comment = null, tracks = []) => {
  const shipment = {
    items: items, // Array of {order_item_id, qty}
    notify: notify ? 1 : 0,
    append_comment: appendComment ? 1 : 0,
    comment: comment,
    tracks: tracks // Array of {track_number, title, carrier_code}
  };

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

  return response;
};

// Usage - Ship with tracking
const shipmentId = await createShipment(12345, [], true, false, 'Your order has shipped!', [
  {
    track_number: '1Z999AA10123456784',
    title: 'Tracking Number',
    carrier_code: 'ups'
  }
]);
console.log(`Shipment created: ${shipmentId}`);

Kundenverwaltung

Kunden abrufen

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;
};

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

Einen Kunden erstellen

Neuen Kunden registrieren:

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;
};

// Usage
const newCustomer = await createCustomer({
  email: 'newcustomer@example.com',
  firstname: 'John',
  lastname: 'Doe',
  password: 'SecurePass123!',
  subscribed: true
});

console.log(`Customer created: ID ${newCustomer.id}`);

Bestandsverwaltung (MSI)

Lagerstatus abrufen

Produktbestand prüfen:

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

// Usage
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}`);

Bestand aktualisieren

Produktmenge 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;
};

// Usage
await updateStock('TSHIRT-001', 100, true);

Webhooks und asynchrone Operationen

Webhooks einrichten

Magento verwendet Nachrichtenwarteschlangen für asynchrone Benachrichtigungen:

// Magento doesn't have native webhooks
// Use these approaches instead:

// 1. Poll orders endpoint periodically
const pollNewOrders = async (lastOrderId) => {
  const orders = await getOrders({
    dateFrom: new Date().toISOString()
  });

  const newOrders = orders.items.filter(o => o.id > lastOrderId);
  return newOrders;
};

// 2. Use Adobe I/O Events (Adobe Commerce only)
// Configure events in Adobe Developer Console

// 3. Create custom webhook module
// See: https://devdocs.magento.com/guides/v2.4/extension-dev-guide/message-queues/message-queues.html

Ratenbegrenzung

Ratenbegrenzungen verstehen

Magento-Ratenbegrenzungen sind konfigurierbar:

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

Im Admin konfigurieren: 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;
      }
    }
  }
};

Checkliste für die Produktivbereitstellung

Vor der 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

Ein Hersteller synchronisiert seinen Bestand:

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

Mobile App

Ein Händler entwickelt eine Shopping-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. Wichtige Erkenntnisse:

• 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?

Verwenden Sie einen Admin-Token für interne Integrationen oder erstellen Sie 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. Verwenden Sie Polling, Adobe I/O Events (Adobe Commerce) oder erstellen Sie ein benutzerdefiniertes Modul.

Wie aktualisiere ich Bestandsmengen?

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