API 2Checkout : Guide d'intégration complet pour le traitement des paiements (2026)

En bref

L'API 2Checkout (désormais Verifone) permet aux développeurs de traiter les paiements, de gérer les abonnements et de gérer les transactions e-commerce par programmation. Elle prend en charge les points d'accès RESTful pour les commandes, les clients, les produits et les webhooks avec une authentification basée sur JSON utilisant des clés API. Ce guide couvre tout, de la configuration initiale à la gestion avancée des webhooks.

Introduction

Le traitement des paiements est l'épine dorsale de toute entreprise en ligne. Si vous vous trompez, vous perdez des revenus. Si vous réussissez, vous ouvrez les marchés mondiaux. L'API 2Checkout (récemment renommée Verifone) gère les paiements pour plus de 45 000 commerçants dans le monde, traitant des milliards de transactions chaque année.

Voici la réalité : 67 % des acheteurs abandonnent leur panier en raison de frictions liées au paiement. Une intégration API de paiement solide a un impact direct sur votre chiffre d'affaires.

Ce guide vous présente le processus complet d'intégration de l'API 2Checkout. Vous apprendrez l'authentification, le traitement des paiements, la gestion des abonnements, la gestion des webhooks et le dépannage des erreurs. À la fin, vous disposerez d'une intégration de paiement prête pour la production.

Qu'est-ce que l'API 2Checkout ?

2Checkout (opérant désormais sous le nom de Verifone Digital Commerce) fournit une API RESTful pour le traitement des paiements et la gestion des abonnements. L'API gère :

• Paiements uniques et récurrents
• Gestion des clients et des produits
• Suivi du cycle de vie des commandes
• Gestion des remboursements et des litiges
• Automatisation des taxes et de la conformité
• Prise en charge de plusieurs devises (plus de 100 devises)

Fonctionnalités Clés

Aperçu de l'Architecture API

2Checkout utilise une structure d'API REST versionnée :

https://api.2checkout.com/1/
https://api.2checkout.com/2/

La version 2 est la version actuellement recommandée avec une gestion des abonnements et des webhooks améliorée.

Démarrer : Configuration de l'Authentification

Étape 1 : Créez Votre Compte 2Checkout

Avant d'accéder à l'API, vous avez besoin d'un compte marchand :

1. Visitez la page d'inscription de 2Checkout (Verifone)
2. Effectuez la vérification de l'entreprise (nécessite des documents commerciaux)
3. Attendez l'approbation (généralement 24-48 heures)
4. Accédez à votre Panneau de Configuration pour récupérer les identifiants API

Étape 2 : Récupérez les Clés API

Naviguez vers Intégrations > Clés API dans votre Panneau de Configuration :

• Clé API Privée : Utilisée pour l'authentification côté serveur (gardez-la secrète)
• Clé API Publique : Utilisée pour la tokenisation côté client (sans danger à exposer)
• Secret de Webhook : Utilisé pour vérifier les signatures de webhook

Note de sécurité : Ne jamais inclure les clés API dans le contrôle de version. Utilisez des variables d'environnement :

# .env file
TWOCHECKOUT_PRIVATE_KEY="your_private_key_here"
TWOCHECKOUT_PUBLIC_KEY="your_public_key_here"
TWOCHECKOUT_WEBHOOK_SECRET="your_webhook_secret_here"

Étape 3 : Bac à Sable vs Production

2Checkout fournit des environnements distincts :

Utilisez les identifiants du bac à sable pendant le développement. Passez aux clés de production uniquement lorsque vous êtes prêt à traiter des paiements réels.

Étape 4 : Méthodes d'Authentification

2Checkout prend en charge deux approches d'authentification :

Méthode 1 : Authentification par Clé API (Recommandée)

Incluez votre clé privée dans l'en-tête de la requête :

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

Méthode 2 : Authentification par Signature HMAC

Pour une sécurité renforcée, signez les requêtes avec HMAC-SHA256 :

const crypto = require('crypto');

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

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

Traitement des Paiements : Points d'Accès Essentiels

Création d'une Commande Unique

Traitez un paiement unique avec le point d'accès /orders :

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 // From client-side tokenization
    }
  };

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

Réponse Attendue

{
  "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"
}

Gestion des Erreurs de Paiement

Implémentez toujours une gestion des erreurs appropriée :

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

  if (result.error) {
    // Handle specific error codes
    switch (result.error.code) {
      case 'CARD_DECLINED':
        // Prompt customer for different card
        break;
      case 'INSUFFICIENT_FUNDS':
        // Show appropriate message
        break;
      case 'INVALID_CVV':
        // Request CVV re-entry
        break;
      default:
        // Log and show generic error
        console.error('Payment failed:', result.error);
    }
  }
} catch (error) {
  // Network or server error
  console.error('API request failed:', error);
}

Codes d'Erreur Courants

Gestion des Clients

La gestion des données clients est essentielle pour les entreprises par abonnement et les achats répétés. 2Checkout fournit une API client complète.

Création d'un Client

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: 'en'
  };

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

Réponse Client

{
  "customer_id": "CUST-2026-123456",
  "email": "john.doe@example.com",
  "first_name": "John",
  "last_name": "Doe",
  "created_at": "2026-03-20T10:00:00Z",
  "updated_at": "2026-03-20T10:00:00Z",
  "payment_methods": [],
  "subscriptions": [],
  "order_history": []
}

Récupération des Détails Client

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

Mise à Jour des Informations Client

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

Suppression d'un Client

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; // No content on success
};

Note : La suppression d'un client ayant des abonnements actifs ou des soldes impayés échouera. Annulez les abonnements d'abord.

Modèles d'Intégration Avancés

Idempotence pour des Retentatives Sûres

Les API de paiement doivent prendre en charge les requêtes idempotentes pour éviter les frais en double :

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 // Unique per order
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

// Generate unique key per order (store in your database)
const idempotencyKey = `order_${userId}_${Date.now()}`;

Si la requête expire mais que 2Checkout l'a traitée, une nouvelle tentative avec la même clé renvoie le résultat original au lieu de facturer deux fois.

Gestion de 3D Secure 2.0 (Conformité UE)

Pour les clients européens, l'authentification 3D Secure 2.0 est obligatoire en vertu de la DSP2 :

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', // or 'mandatory' for EU
        notification_url: 'https://your-site.com/3ds-callback'
      }
    })
  });

  const result = await response.json();

  // Handle 3DS redirect
  if (result.three_ds_redirect_url) {
    // Redirect customer to their bank for authentication
    res.redirect(result.three_ds_redirect_url);
  }

  return result;
};

Tarification Multi-Devises

Affichez les prix dans les devises locales tout en étant réglé dans votre devise de base :

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

// Usage
const eurPrice = await getLocalizedPrice(99.99, 'EUR');
console.log(`Price: EUR ${eurPrice.toFixed(2)}`);

Prorata pour les Mises à Niveau d'Abonnement

Lorsque les clients mettent à niveau leur abonnement en cours de cycle, calculez les frais au prorata :

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', // Charge difference now
        invoice_proration: true  // Show line item on invoice
      })
    }
  );

  return await response.json();
};

Dépannage des Problèmes Courants

Problème : Les Webhooks n'Arrivent Pas

Symptômes : Les commandes sont traitées mais votre système ne se met pas à jour.

Diagnostic :

// Check webhook delivery logs in 2Checkout dashboard
// Look for failed delivery attempts or non-200 responses

Solutions :

1. Vérifiez que le point d'accès renvoie 200 OK dans les 5 secondes
2. Vérifiez la validité du certificat SSL (doit être HTTPS)
3. Mettez en liste blanche les plages d'adresses IP de 2Checkout dans votre pare-feu
4. Examinez la logique de vérification de la signature du webhook
5. Testez avec un simulateur de webhook avant la production

Problème : Les Paiements de Test Échouent dans le Bac à Sable

Symptômes : Toutes les cartes de test sont refusées dans l'environnement de bac à sable.

Solutions :

1. Confirmez l'utilisation des clés API du bac à sable (pas de production)
2. Vérifiez l'URL de base du bac à sable : https://sandbox.2checkout.com/api/
3. Utilisez les numéros de carte de test corrects (voir la section Tests)
4. Vérifiez l'état du compte du bac à sable (peut expirer après inactivité)

Problème : Les Renouvellements d'Abonnement Échouent Silencieusement

Symptômes : Les abonnements apparaissent comme actifs mais les renouvellements ne sont pas traités.

Diagnostic :

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

Solutions :

1. Vérifiez l'expiration du mode de paiement du client
2. Examinez les paramètres de recouvrement dans le Panneau de Configuration
3. Vérifiez la livraison du webhook pour subscription.payment_failed
4. Confirmez que le drapeau auto_renew est activé

Problème : Discrépances de Conversion de Devise

Symptômes : Le montant facturé diffère de la conversion attendue.

Cause : 2Checkout utilise des taux de change quotidiens, qui fluctuent.

Solution :

• Afficher une conversion « approximative » avec une clause de non-responsabilité
• Bloquer les taux lors de la création du panier avec une expiration de 15 minutes
• Stocker les transactions dans la devise locale du client

Problème : Échecs de la Vérification d'Adresse (AVS)

Symptômes : Les cartes légitimes sont refusées en raison d'une non-concordance d'adresse.

Solutions :

1. Utilisez la saisie semi-automatique d'adresses (Google Places, Lob)
2. Rendez le code postal obligatoire à la caisse
3. Implémentez un AVS souple (avertir au lieu de refuser)
4. Permettre au client de mettre à jour l'adresse de facturation

Gestion des Abonnements

2Checkout excelle dans la facturation récurrente. Voici comment gérer les abonnements :

Création d'un Abonnement

const createSubscription = async (customerId, planId) => {
  const payload = {
    customer_id: customerId,
    plan_id: planId,
    start_date: new Date().toISOString(),
    billing_cycle: 'monthly', // or 'annual', 'weekly'
    payment_method: {
      type: 'card',
      card_token: 'tok_card_tokenized'
    },
    options: {
      trial_days: 14, // Optional free trial
      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();
};

Réponse d'Abonnement

{
  "subscription_id": "SUB-2026-567890",
  "status": "active",
  "plan_id": "PLAN-PREMIUM-MONTHLY",
  "customer_id": "CUST-789456",
  "current_period_start": "2026-03-20T00:00:00Z",
  "current_period_end": "2026-04-20T00:00:00Z",
  "trial_end": "2026-04-03T00:00:00Z",
  "amount": 29.99,
  "currency": "USD"
}

Mise à Jour d'un Abonnement

Modifiez les plans, mettez à jour les modes de paiement ou modifiez les quantités :

const updateSubscription = async (subscriptionId, updates) => {
  const payload = {
    ...updates
    // Examples:
    // plan_id: 'PLAN-ENTERPRISE-MONTHLY',
    // quantity: 5,
    // payment_method: { card_token: 'new_token' }
  };

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

Annulation d'un Abonnement

const cancelSubscription = async (subscriptionId, reason = '') => {
  const payload = {
    cancel_at_period_end: false, // true = cancel after current period, false = immediate
    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();
};

Intégration des Webhooks : Gestion des Événements en Temps Réel

Les webhooks informent votre système des événements de paiement sans interrogation. C'est essentiel pour les renouvellements d'abonnements, les paiements échoués et les remboursements.

Étape 1 : Configurez le Point d'Accès du Webhook

Dans votre Panneau de Configuration 2Checkout :

1. Naviguez vers Intégrations > Webhooks
2. Ajoutez l'URL de votre point d'accès (doit utiliser HTTPS)
3. Sélectionnez les événements auxquels vous abonner
4. Enregistrez et notez votre Secret de Webhook

Étape 2 : Créez un Gestionnaire de Webhook

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;

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

  if (!isValid) {
    console.error('Invalid webhook signature');
    return res.status(401).send('Unauthorized');
  }

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

  // Route to appropriate handler
  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('Unhandled event type:', event.type);
  }

  // Acknowledge receipt
  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')
  );
}

Événements Webhook Critiques

Bonnes Pratiques des Webhooks

1. Toujours vérifier les signatures - Empêche les webhooks falsifiés
2. Retourner 200 OK rapidement - 2Checkout réessaie en cas de réponses non-200
3. Traiter de manière asynchrone - Mettre en file d'attente les événements pour un traitement en arrière-plan
4. Implémenter l'idempotence - Gérer les livraisons de webhooks en double
5. Tout enregistrer - Déboguer les litiges de paiement avec des journaux horodatés

Test de Votre Intégration

Utilisation de l'Environnement de Bac à Sable

Le bac à sable de 2Checkout vous permet de tester sans frais réels :

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

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

// Test addresses
const TEST_ADDRESS = {
  country: 'US',
  zip: '90210' // Triggers AVS checks
};

Test des Webhooks Localement

Utilisez ngrok pour exposer votre serveur local :

# Install ngrok
npm install -g ngrok

# Start your server on port 3000
node server.js

# Expose to internet
ngrok http 3000

# Copy the ngrok URL to 2Checkout webhook settings

Apidog pour le Test d'API

Apidog simplifie les tests de l'API 2Checkout :

1. Importer la spécification OpenAPI - Chargez la définition de l'API 2Checkout
2. Créer des Scénarios de Test - Créez des collections pour chaque point d'accès
3. Simuler des Réponses - Testez sans interroger l'API
4. Valider les Webhooks - Inspectez les structures de charge utile
5. Partager avec l'Équipe - Collaborez sur les tests d'intégration

Créez des variables d'environnement pour les clés du bac à sable vs production, puis changez de contexte en un clic.

Liste de Contrôle du Déploiement en Production

Avant de passer en direct :

• [ ] Passer des clés API du bac à sable aux clés de production
• [ ] Mettre à jour l'URL de base vers https://api.2checkout.com/
• [ ] Activer la vérification de la signature du webhook
• [ ] Configurer la surveillance des paiements échoués
• [ ] Configurer la logique de nouvelle tentative pour les échecs transitoires
• [ ] Tester les flux de remboursement et de rétrofacturation
• [ ] Vérifier la conformité PCI DSS (utiliser la tokenisation)
• [ ] Activer 3D Secure 2.0 pour les clients de l'UE
• [ ] Configurer la journalisation pour les pistes d'audit
• [ ] Créer un guide opérationnel pour les problèmes de paiement

Surveillance et Alertes

Suivez ces métriques :

// Example: Payment success rate
const successRate = approvedOrders / totalOrders * 100;

if (successRate < 95) {
  // Alert payment team
  sendAlert('Payment success rate dropped below 95%');
}

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

// Alert on spike in specific errors
if (errorBreakdown['CARD_DECLINED'] > threshold) {
  sendAlert('Spike in card declines detected');
}

Cas d'Utilisation Réels

Intégration d'une Boutique E-commerce

Un détaillant de mode a intégré 2Checkout pour gérer les paiements mondiaux. Résultats :

• Prise en charge automatique de plus de 100 devises
• Réduction de l'abandon de panier de 23 %
• Gestion automatique de la conformité à la TVA de l'UE
• Traité plus de 2 millions de dollars la première année

L'implémentation a pris 3 semaines en utilisant initialement les pages de paiement hébergées de 2Checkout, puis a migré vers une intégration API directe pour une UX personnalisée.

Entreprise d'Abonnement SaaS

Un SaaS de gestion de projet a utilisé les abonnements 2Checkout :

• Géré plus de 5 000 abonnements actifs
• Géré le prorata pour les mises à niveau de plan
• Recouvrement automatisé pour les renouvellements échoués
• Réduction de l'attrition de 15 % grâce à des tentatives intelligentes

Fonctionnalité clé : Contrôle d'accès basé sur les webhooks. Lorsque subscription.renewed arrive, étendez instantanément l'accès de l'utilisateur. Lorsque subscription.cancelled, planifiez la révocation de l'accès.

Conclusion

L'API 2Checkout fournit tout le nécessaire pour le traitement des paiements et la gestion des abonnements. Points clés à retenir :

• Utilisez l'environnement de bac à sable pour tout le développement et les tests
• Implémentez la vérification de la signature HMAC pour les webhooks
• Gérez les erreurs avec élégance grâce à une gestion spécifique des codes d'erreur
• Testez minutieusement les flux d'abonnement (essai, renouvellement, annulation)
• Surveillez les métriques de paiement en production
• Utilisez Apidog pour rationaliser les tests d'API et la collaboration d'équipe

Section FAQ

Qu'est-ce que l'API 2Checkout ?

L'API 2Checkout (désormais Verifone) est une interface RESTful pour le traitement des paiements, la gestion des abonnements, la gestion des remboursements et l'automatisation des transactions e-commerce. Elle prend en charge les charges utiles JSON, l'authentification HMAC et les webhooks en temps réel.

2Checkout est-il identique à Verifone ?

Oui. 2Checkout a été acquis par Verifone en 2020 et a été renommé Verifone Digital Commerce. Les points d'accès API et les fonctionnalités restent les mêmes, bien que certaines documentations fassent référence à Verifone.

Comment obtenir ma clé API 2Checkout ?

Connectez-vous à votre Panneau de Configuration 2Checkout, naviguez vers Intégrations > Clés API, et générez une nouvelle clé. Vous recevrez une clé privée (côté serveur) et une clé publique (tokenisation côté client).

2Checkout dispose-t-il d'un environnement de bac à sable ?

Oui. Utilisez https://sandbox.2checkout.com/api/ pour les tests. Créez un compte de bac à sable distinct pour obtenir des clés API de test et traiter des transactions de test sans frais réels.

Quels modes de paiement 2Checkout prend-il en charge ?

2Checkout prend en charge les cartes de crédit (Visa, Mastercard, Amex, Discover), PayPal, Apple Pay, Google Pay, les virements bancaires et les méthodes de paiement locales dans plus de 100 pays.

Comment gérer les webhooks en toute sécurité ?

Vérifiez toujours l'en-tête X-Webhook-Signature à l'aide de HMAC-SHA256 avec votre secret de webhook. Traitez les événements de manière asynchrone et renvoyez un code 200 OK immédiatement pour éviter les nouvelles tentatives.

Que se passe-t-il lorsqu'un paiement d'abonnement échoue ?

2Checkout envoie un webhook subscription.payment_failed. Implémentez une logique de nouvelle tentative (généralement 3 tentatives sur 7 jours) et envoyez un webhook subscription.cancelled si toutes les tentatives échouent.

2Checkout est-il conforme PCI DSS ?

Oui, 2Checkout est certifié PCI DSS Niveau 1. Utilisez la tokenisation côté client pour éviter de manipuler des données de carte brutes, ce qui réduit votre périmètre de conformité PCI.

Puis-je tester les abonnements dans le bac à sable ?

Oui. Le bac à sable prend en charge les tests complets du cycle de vie des abonnements, y compris les essais, les renouvellements, les mises à niveau, les déclassements et les annulations. Utilisez la carte de test 4111111111111111 pour les paiements réussis.

Comment gérer les remboursements via l'API ?

Envoyez une requête POST à /refunds avec l'ID de commande et le montant du remboursement. 2Checkout traite les remboursements partiels ou complets et envoie un webhook refund.processed une fois terminé.