DEV Community

Cover image for 2Checkout API: Vollständige Integrationsanleitung für Zahlungsabwicklung (2026)
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

2Checkout API: Vollständige Integrationsanleitung für Zahlungsabwicklung (2026)

#api #backend #tutorial #webdev

TL;DR

Die 2Checkout API (jetzt Verifone) ermöglicht Entwicklern die programmatische Abwicklung von Zahlungen, die Verwaltung von Abonnements und die Handhabung von E-Commerce-Transaktionen. Sie unterstützt RESTful-Endpunkte für Bestellungen, Kunden, Produkte und Webhooks mit JSON-basierter Authentifizierung mittels API-Schlüsseln. Dieser Leitfaden deckt alles ab, von der Ersteinrichtung bis zur erweiterten Webhook-Verarbeitung.

Teste Apidog noch heute

Einführung

Die Zahlungsabwicklung ist das Rückgrat jedes Online-Geschäfts. Fehler kosten Umsatz, eine saubere Integration erschließt globale Märkte. Die 2Checkout API (nun Verifone) wickelt Zahlungen für über 45.000 Händler ab und verarbeitet Milliardenumsätze jährlich.

67 % der Käufer brechen den Kauf wegen Zahlungsproblemen ab. Deine Payment-Integration beeinflusst direkt das Geschäftsergebnis.

In diesem Guide erhältst du einen umsetzungsorientierten Fahrplan zur Implementierung der 2Checkout API – von Authentifizierung, Zahlung, Abo-Management und Webhook-Handling bis zur Fehlerbehebung. Nach dem Durcharbeiten hast du eine produktionsreife Zahlungsintegration.

💡 Tipp: Apidog beschleunigt API-Tests: Teste 2Checkout-Endpunkte, validiere Webhook-Payloads und debugge Authentifizierungsprobleme zentral. Importiere die OpenAPI-Spezifikation, simuliere Antworten und teile Testszenarien mit dem Team.

Was ist die 2Checkout API?

2Checkout (jetzt Verifone Digital Commerce) bietet eine RESTful API für Zahlungsabwicklung und Subscription-Management. Typische Anwendungsfälle:

  • Einmalige und wiederkehrende Zahlungen
  • Kunden- und Produktverwaltung
  • Bestell-Lifecycle-Tracking
  • Rückerstattungen und Dispute-Handling
  • Automatisierte Steuer- und Compliance-Prozesse
  • Multiwährungssupport (100+ Währungen)

Hauptfunktionen

Funktion Beschreibung
RESTful Design Standard-HTTP-Methoden (GET, POST, PUT, DELETE) mit JSON-Payloads
Sandbox Testzahlungen ohne echte Transaktionen
Webhooks Echtzeit-Benachrichtigungen bei Bestellereignissen
Tokenisierung Sichere Zahlungsdatenverarbeitung ohne Kartendaten-Speicherung
Globale Compliance PCI DSS Level 1, GDPR, PSD2, 3D Secure 2.0

Übersicht der API-Architektur

2Checkout nutzt versionierte API-Pfade:

https://api.2checkout.com/1/
https://api.2checkout.com/2/
Enter fullscreen mode Exit fullscreen mode

Nutze Version 2 für neue Projekte – sie bietet bessere Abo- und Webhook-Funktionen.

Erste Schritte: Authentifizierung einrichten

Schritt 1: 2Checkout-Konto anlegen

  1. Registriere dich auf der 2Checkout (Verifone) Seite
  2. Reiche Geschäftsunterlagen zur Verifizierung ein
  3. Warte auf Genehmigung (ca. 24–48h)
  4. Greife aufs Control Panel zu und hole dir die API-Keys

Schritt 2: API-Schlüssel abrufen

Im Control Panel unter Integrationen > API-Schlüssel findest du:

  • Privater API-Schlüssel (nur serverseitig, geheim halten)
  • Öffentlicher API-Schlüssel (für clientseitige Tokenisierung)
  • Webhook Secret (für Webhook-Validierung)

Sicherheit: Lege API-Keys nie ins Git! Nutze Umgebungsvariablen:

# .env-Datei
TWOCHECKOUT_PRIVATE_KEY="Ihr_privater_schlüssel_hier"
TWOCHECKOUT_PUBLIC_KEY="Ihr_öffentlicher_schlüssel_hier"
TWOCHECKOUT_WEBHOOK_SECRET="Ihr_webhook_geheimnis_hier"
Enter fullscreen mode Exit fullscreen mode

Schritt 3: Sandbox vs. Produktion

Umgebung Basis-URL Zweck
Sandbox https://sandbox.2checkout.com/api/ Entwicklung & Tests
Produktiv https://api.2checkout.com/ Live-Transaktionen

Teste in der Sandbox, produktive Schlüssel nur live verwenden.

Schritt 4: Authentifizierungsmethoden

Methode 1: API-Key (empfohlen) 

const response = await fetch('https://api.2checkout.com/1/orders', {
  method: 'GET',
  headers: {
    'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
});
Enter fullscreen mode Exit fullscreen mode

Methode 2: HMAC-Signatur für erhöhte Sicherheit 

const crypto = require('crypto');

function generateSignature(payload, privateKey) {
  const hash = crypto
    .createHmac('sha256', privateKey)
    .update(JSON.stringify(payload))
    .digest('hex');
  return hash;
}

// Verwendung
const payload = { order_id: '12345', amount: 99.99 };
const signature = generateSignature(payload, privateKey);

const response = await fetch('https://api.2checkout.com/1/orders', {
  method: 'POST',
  headers: {
    'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
    'X-Signature': signature,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
});
Enter fullscreen mode Exit fullscreen mode

Screenshot eines Code-Beispiels für die 2Checkout HMAC-Signatur-Authentifizierung.

Zahlungsabwicklung: Kern-Endpunkte

Einmalige Bestellung erstellen 

const createOrder = async (customerData, productData) => {
  const payload = {
    currency: 'USD',
    customer: {
      email: customerData.email,
      first_name: customerData.firstName,
      last_name: customerData.lastName,
      phone: customerData.phone,
      billing_address: {
        address1: customerData.address,
        city: customerData.city,
        state: customerData.state,
        zip: customerData.zip,
        country: customerData.country
      }
    },
    items: [
      {
        name: productData.name,
        quantity: productData.quantity,
        price: productData.price,
        product_code: productData.sku
      }
    ],
    payment_method: {
      type: 'card',
      card_token: customerData.cardToken // Vom clientseitigen Tokenisierungsprozess
    }
  };

  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};
Enter fullscreen mode Exit fullscreen mode

Erwartete Antwort 

{
  "order_id": "ORD-2026-001234",
  "status": "approved",
  "amount": 99.99,
  "currency": "USD",
  "customer_id": "CUST-789456",
  "transaction_id": "TXN-9876543210",
  "created_at": "2026-03-20T10:30:00Z"
}
Enter fullscreen mode Exit fullscreen mode

Fehlerbehandlung

Implementiere robuste Behandlung von Zahlungsfehlern:

try {
  const result = await createOrder(customer, product);

  if (result.error) {
    switch (result.error.code) {
      case 'CARD_DECLINED':
        // Andere Karte anfordern
        break;
      case 'INSUFFICIENT_FUNDS':
        // Info anzeigen
        break;
      case 'INVALID_CVV':
        // CVV erneut abfragen
        break;
      default:
        console.error('Zahlung fehlgeschlagen:', result.error);
    }
  }
} catch (error) {
  // Netzwerk- oder Serverfehler
  console.error('API-Anfrage fehlgeschlagen:', error);
}
Enter fullscreen mode Exit fullscreen mode

Typische Fehlercodes

Fehlercode HTTP Beschreibung Lösung
CARD_DECLINED 402 Karte wurde abgelehnt Anderes Zahlungsmittel
INVALID_CARD 400 Ungültige Kartennummer Daten validieren
EXPIRED_CARD 400 Karte abgelaufen Ablaufdatum aktualisieren
INVALID_CVV 400 CVV falsch CVV erneut anfordern
INSUFFICIENT_FUNDS 402 Nicht genug Guthaben Alternative vorschlagen
DUPLICATE_ORDER 409 Bestellung schon bearbeitet Duplikate prüfen
INVALID_CURRENCY 400 Nicht unterstützte Währung Währungscode prüfen
API_KEY_INVALID 401 Authentifizierung fehlgeschlagen API-Key prüfen

Kundenverwaltung

Für Abos und wiederkehrende Käufe ist eine Kunden-API nötig.

Kunden anlegen 

const createCustomer = async (customerData) => {
  const payload = {
    email: customerData.email,
    first_name: customerData.firstName,
    last_name: customerData.lastName,
    phone: customerData.phone,
    company: customerData.company,
    billing_address: {
      address1: customerData.address,
      address2: customerData.address2 || '',
      city: customerData.city,
      state: customerData.state,
      zip: customerData.zip,
      country: customerData.country
    },
    shipping_address: customerData.shippingAddress || null,
    tax_exempt: false,
    language: 'de'
  };

  const response = await fetch('https://api.2checkout.com/1/customers', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};
Enter fullscreen mode Exit fullscreen mode

Kunde abrufen 

const getCustomer = async (customerId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'GET',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      }
    }
  );

  return await response.json();
};
Enter fullscreen mode Exit fullscreen mode

Kunde aktualisieren 

const updateCustomer = async (customerId, updates) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'PUT',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(updates)
    }
  );

  return await response.json();
};
Enter fullscreen mode Exit fullscreen mode

Kunde löschen 

const deleteCustomer = async (customerId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/customers/${customerId}`,
    {
      method: 'DELETE',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY
      }
    }
  );

  return response.status === 204;
};
Enter fullscreen mode Exit fullscreen mode

Hinweis: Löschen nur, wenn keine offenen Abos oder Beträge.

Erweiterte Integrationsmuster

Idempotenz für sichere Wiederholungen 

const createIdempotentOrder = async (payload, idempotencyKey) => {
  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json',
      'X-Idempotency-Key': idempotencyKey
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

const idempotencyKey = `order_${userId}_${Date.now()}`;
Enter fullscreen mode Exit fullscreen mode

3D Secure 2.0 (EU-Compliance) 

const createOrderWith3DS = async (payload) => {
  const response = await fetch('https://api.2checkout.com/1/orders', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      ...payload,
      three_ds: {
        enabled: true,
        challenge_required: 'preferred',
        notification_url: 'https://your-site.com/3ds-callback'
      }
    })
  });

  const result = await response.json();

  if (result.three_ds_redirect_url) {
    res.redirect(result.three_ds_redirect_url);
  }

  return result;
};
Enter fullscreen mode Exit fullscreen mode

Multiwährungs-Preise 

const getLocalizedPrice = async (basePrice, targetCurrency) => {
  const response = await fetch(
    `https://api.2checkout.com/1/rates?from=USD&to=${targetCurrency}`,
    {
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY
      }
    }
  );

  const rates = await response.json();
  return basePrice * rates.rate;
};

const eurPrice = await getLocalizedPrice(99.99, 'EUR');
console.log(`Preis: EUR ${eurPrice.toFixed(2)}`);
Enter fullscreen mode Exit fullscreen mode

Pro-Rata für Abo-Upgrades 

const upgradeSubscription = async (subscriptionId, newPlanId) => {
  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}/upgrade`,
    {
      method: 'POST',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        plan_id: newPlanId,
        proration: 'immediate',
        invoice_proration: true
      })
    }
  );

  return await response.json();
};
Enter fullscreen mode Exit fullscreen mode

Fehlerbehebung: Typische Probleme

Webhooks kommen nicht an

Diagnose:

// Webhook-Zustellprotokolle im 2Checkout-Dashboard checken
// Auf fehlgeschlagene/Non-200-Antworten prüfen
Enter fullscreen mode Exit fullscreen mode

Lösungen:

  1. Endpunkt muss in 5s 200 OK liefern
  2. SSL-Zertifikat prüfen (HTTPS!)
  3. 2Checkout-IPs in Firewall whitelisten
  4. Webhook-Signaturprüfung checken
  5. Mit Webhook-Simulator testen

Sandbox-Testzahlungen schlagen fehl

Lösungen:

  1. Nutze Sandbox-API-Schlüssel
  2. Sandbox-URL korrekt? https://sandbox.2checkout.com/api/
  3. Testkartennummern verwenden (siehe Testen)
  4. Sandbox-Konto aktiv?

Aboverlängerungen schlagen fehl

Diagnose:

const history = await fetch(
  `https://api.2checkout.com/1/subscriptions/${subId}/payments`,
  { headers: { 'X-Api-Key': privateKey } }
);
Enter fullscreen mode Exit fullscreen mode

Lösungen:

  1. Ablaufdatum der Karte prüfen
  2. Dunning-Settings im Panel checken
  3. Webhook-Zustellung für subscription.payment_failed prüfen
  4. auto_renew aktiv?

Abweichungen bei Währungsumrechnung

  • 2Checkout nutzt Tageskurse.
  • Zeige „ungefähre“ Preise an, Kurs 15 Minuten lang fixieren, lokale Währung speichern.

AVS-Fehler (Adressverifizierung)

Lösungen:

  1. Autovervollständigung für Adressen nutzen
  2. PLZ als Pflichtfeld
  3. Soft-AVS: Warnung statt Block
  4. Rechnungsadresse editierbar machen

Abonnementverwaltung

2Checkout ist für wiederkehrende Abrechnung optimiert.

Neues Abo erstellen 

const createSubscription = async (customerId, planId) => {
  const payload = {
    customer_id: customerId,
    plan_id: planId,
    start_date: new Date().toISOString(),
    billing_cycle: 'monthly',
    payment_method: {
      type: 'card',
      card_token: 'tok_card_tokenized'
    },
    options: {
      trial_days: 14,
      auto_renew: true
    }
  };

  const response = await fetch('https://api.2checkout.com/1/subscriptions', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};
Enter fullscreen mode Exit fullscreen mode

Abo aktualisieren 

const updateSubscription = async (subscriptionId, updates) => {
  const payload = { ...updates };

  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}`,
    {
      method: 'PUT',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    }
  );

  return await response.json();
};
Enter fullscreen mode Exit fullscreen mode

Abo kündigen 

const cancelSubscription = async (subscriptionId, reason = '') => {
  const payload = {
    cancel_at_period_end: false,
    reason: reason
  };

  const response = await fetch(
    `https://api.2checkout.com/1/subscriptions/${subscriptionId}/cancel`,
    {
      method: 'POST',
      headers: {
        'X-Api-Key': process.env.TWOCHECKOUT_PRIVATE_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
    }
  );

  return await response.json();
};
Enter fullscreen mode Exit fullscreen mode

Webhook-Integration: Echtzeit-Ereignisse

Webhooks liefern Zahlungsereignisse in Echtzeit – essenziell für Aboverlängerungen, Rückerstattungen, Zahlungsausfälle.

Schritt 1: Webhook-Endpunkt anlegen

  1. Im Control Panel unter Integrationen > Webhooks
  2. HTTPS-Endpunkt-URL eintragen
  3. Ereignisse auswählen
  4. Webhook Secret speichern

Schritt 2: Webhook-Handler implementieren 

const express = require('express');
const crypto = require('crypto');
const app = express();

app.post('/webhooks/2checkout', express.raw({ type: 'application/json' }), async (req, res) => {
  const signature = req.headers['x-webhook-signature'];
  const payload = req.body;

  const isValid = verifyWebhookSignature(payload, signature, process.env.TWOCHECKOUT_WEBHOOK_SECRET);

  if (!isValid) {
    console.error('Ungültige Webhook-Signatur');
    return res.status(401).send('Nicht autorisiert');
  }

  const event = JSON.parse(payload.toString());

  switch (event.type) {
    case 'order.created':
      await handleOrderCreated(event.data);
      break;
    case 'order.approved':
      await handleOrderApproved(event.data);
      break;
    case 'order.declined':
      await handleOrderDeclined(event.data);
      break;
    case 'subscription.created':
      await handleSubscriptionCreated(event.data);
      break;
    case 'subscription.renewed':
      await handleSubscriptionRenewed(event.data);
      break;
    case 'subscription.cancelled':
      await handleSubscriptionCancelled(event.data);
      break;
    case 'refund.processed':
      await handleRefundProcessed(event.data);
      break;
    default:
      console.log('Unbehandelter Ereignistyp:', event.type);
  }

  res.status(200).send('OK');
});

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(expectedSignature, 'hex')
  );
}
Enter fullscreen mode Exit fullscreen mode

Kritische Webhook-Events

Event-Typ Auslöser Aktion
order.created Neue Bestellung Bestätigungs-E-Mail senden
order.approved Zahlung erfolgreich Bestellung ausführen, Zugang geben
order.declined Zahlung abgelehnt Kunde benachrichtigen
subscription.renewed Wiederkehrende Zahlung Abo verlängern
subscription.payment_failed Aboverlängerung fehlgeschl. Dunning-Sequenz starten
subscription.cancelled Kündigung Zugang entziehen
refund.processed Rückerstattung Guthaben aktualisieren
chargeback.received Chargeback Belege sammeln

Webhook-Best Practices

  1. Signaturen immer prüfen
  2. Schnell 200 OK zurückgeben
  3. Asynchron verarbeiten (z.B. Warteschlange)
  4. Idempotenz für doppelte Events
  5. Logging für Debug und Audit

Integration testen

Sandbox nutzen 

const BASE_URL = 'https://sandbox.2checkout.com/api/1';

const TEST_CARDS = {
  APPROVED: '4111111111111111',
  DECLINED: '4000000000000002',
  INSUFFICIENT_FUNDS: '4000000000009995',
  EXPIRED_CARD: '4000000000000069'
};

const TEST_ADDRESS = {
  country: 'US',
  zip: '90210'
};
Enter fullscreen mode Exit fullscreen mode

Webhooks lokal testen 

npm install -g ngrok
node server.js
ngrok http 3000
# ngrok-URL bei 2Checkout als Webhook-Endpunkt eintragen
Enter fullscreen mode Exit fullscreen mode

Apidog für API-Tests

  • OpenAPI-Spec importieren
  • Testszenarien pro Endpoint anlegen
  • Antworten simulieren
  • Webhook-Payloads validieren
  • Tests mit Team teilen

Nutze Umgebungsvariablen für Sandbox/Produktiv und wechsle per Klick.

Produktions-Checkliste

Vor Go-Live:

  • [ ] Sandbox- durch Produktions-API-Key ersetzen
  • [ ] Basis-URL auf https://api.2checkout.com/ setzen
  • [ ] Webhook-Signaturprüfung aktivieren
  • [ ] Überwachung für Fehlzahlungen
  • [ ] Retry-Logik für temporäre Fehler
  • [ ] Refund- und Chargeback-Workflows testen
  • [ ] PCI DSS-Konformität (Tokenisierung)
  • [ ] 3D Secure 2.0 für EU aktivieren
  • [ ] Logging/Audit-Trail aktiv
  • [ ] Runbook für Payment-Issues dokumentiert

Überwachung & Alarmierung 

const successRate = approvedOrders / totalOrders * 100;

if (successRate < 95) {
  sendAlert('Zahlungserfolgsrate unter 95%');
}

const errorBreakdown = errors.reduce((acc, err) => {
  acc[err.code] = (acc[err.code] || 0) + 1;
  return acc;
}, {});

if (errorBreakdown['CARD_DECLINED'] > threshold) {
  sendAlert('Anstieg bei Kartenablehnungen');
}
Enter fullscreen mode Exit fullscreen mode

Praxisbeispiele

E-Commerce-Shop

  • 100+ Währungen unterstützt
  • Warenkorbabbrüche um 23% gesenkt
  • EU-Steuerautomatisierung
  • $2 Mio. Umsatz im ersten Jahr
  • Start mit gehosteten Checkout-Seiten, später API-Integration

SaaS-Abo-Geschäft

  • 5.000+ aktive Abos
  • Pro-Rata-Upgrade
  • Automat. Dunning bei Verlängerungsfehler
  • 15% weniger Churn
  • Webhook-gesteuerte Zugriffskontrolle: Zugang nach subscription.renewed verlängern, bei subscription.cancelled entziehen

Fazit

Die 2Checkout API bietet alles für Zahlungs- und Aboverwaltung. Praktische Empfehlungen:

  • Sandbox für Entwicklung & Tests nutzen
  • HMAC-Signatur für Webhooks implementieren
  • Fehler differenziert behandeln
  • Abo-Workflows (Test, Verlängerung, Kündigung) gründlich testen
  • Zahlungsmetriken produktiv überwachen
  • Apidog für API-Tests und Zusammenarbeit einsetzen

FAQ-Bereich

Was ist die 2Checkout API?

Die 2Checkout API (jetzt Verifone) ist eine RESTful-Schnittstelle zur Abwicklung von Zahlungen, Verwaltung von Abonnements, Bearbeitung von Rückerstattungen und Automatisierung von E-Commerce-Transaktionen. Sie unterstützt JSON-Payloads, HMAC-Authentifizierung und Echtzeit-Webhooks.

Ist 2Checkout dasselbe wie Verifone?

Ja. 2Checkout wurde 2020 von Verifone übernommen und in Verifone Digital Commerce umbenannt. Die API-Endpunkte und Funktionalitäten bleiben gleich, Dokumentationen beziehen sich teils auf Verifone.

Wie erhalte ich meinen 2Checkout API-Schlüssel?

Im 2Checkout Control Panel unter Integrationen > API-Schlüssel neuen Schlüssel generieren. Du erhältst einen privaten Schlüssel (serverseitig) und einen öffentlichen Schlüssel (Tokenisierung).

Hat 2Checkout eine Sandbox?

Ja. Für Tests: https://sandbox.2checkout.com/api/ verwenden. Sandbox-Konto anlegen und Test-API-Keys nutzen.

Welche Zahlungsmethoden unterstützt 2Checkout?

Kreditkarten (Visa, Mastercard, Amex, Discover), PayPal, Apple Pay, Google Pay, Banküberweisung und lokale Zahlungsmethoden in 100+ Ländern.

Wie gehe ich sicher mit Webhooks um?

Den X-Webhook-Signature-Header immer mit HMAC-SHA256 und deinem Secret prüfen. Events asynchron verarbeiten und sofort 200 OK zurückgeben.

Was passiert bei fehlgeschlagener Abozahlung?

2Checkout sendet einen subscription.payment_failed-Webhook. Implementiere Retry-Logik (z.B. 3 Versuche in 7 Tagen); bei Misserfolg kommt ein subscription.cancelled-Webhook.

Ist 2Checkout PCI DSS-konform?

Ja, PCI DSS Level 1. Nutze clientseitige Tokenisierung, damit du keine echten Kartendaten verarbeiten musst.

Kann ich Abos in der Sandbox testen?

Ja. Vollständiger Test des Abo-Lebenszyklus inkl. Testphase, Verlängerung, Upgrade, Downgrade und Kündigung. Testkarte: 4111111111111111.

Wie bearbeite ich Rückerstattungen per API?

Sende eine POST-Anfrage an /refunds mit Bestell-ID und Betrag. 2Checkout verarbeitet (Teil-)Rückerstattungen und sendet einen refund.processed-Webhook nach Abschluss.

Top comments (0)