DEV Community

Cover image for API 2Checkout : Guide d'intégration complet pour le traitement des paiements (2026)
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

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.

Essayez Apidog dès aujourd'hui

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.

💡 Astuce : Apidog simplifie les tests d'intégration d'API. Testez vos points d'accès 2Checkout, validez les charges utiles de webhook et déboguez les problèmes d'authentification dans un seul espace de travail. Importez la spécification OpenAPI de 2Checkout, simulez les réponses et partagez les scénarios de test avec votre équipe.

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 plus de 100 devises

Fonctionnalités Clés

Fonctionnalité Description
Conception RESTful Méthodes HTTP standard (GET, POST, PUT, DELETE) avec des charges utiles JSON
Environnement de Bac à Sable Testez les paiements sans traiter de transactions réelles
Prise en charge des Webhooks Notifications en temps réel pour les événements de commande
Tokenisation Traitement sécurisé des données de paiement sans stockage des détails de carte
Conformité Mondiale PCI DSS Niveau 1, GDPR, PSD2 et 3D Secure 2.0

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/
Enter fullscreen mode Exit fullscreen mode

La version 2 est recommandée pour ses fonctionnalités avancées sur la gestion des abonnements et des webhooks.

Démarrer : Configuration de l'Authentification

Étape 1 : Créez Votre Compte 2Checkout

  1. Rendez-vous sur la page d'inscription 2Checkout (Verifone)
  2. Effectuez la vérification de l'entreprise (documents requis)
  3. Attendez l'approbation (24-48h)
  4. Accédez au Panneau de Configuration pour récupérer vos identifiants API

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

Dans Intégrations > Clés API du Panneau de Configuration :

  • Clé API Privée : Authentification côté serveur (gardez-la secrète)
  • Clé API Publique : Tokenisation côté client
  • Secret de Webhook : Pour vérifier les signatures de webhook

Bonnes pratiques : N'ajoutez jamais les clés API au contrôle de version. Utilisez des variables d'environnement :

# .env
TWOCHECKOUT_PRIVATE_KEY="your_private_key_here"
TWOCHECKOUT_PUBLIC_KEY="your_public_key_here"
TWOCHECKOUT_WEBHOOK_SECRET="your_webhook_secret_here"
Enter fullscreen mode Exit fullscreen mode

Étape 3 : Bac à Sable vs Production

Environnement URL de Base Cas d'Utilisation
Bac à Sable https://sandbox.2checkout.com/api/ Développement et tests
Production https://api.2checkout.com/ Transactions réelles

Utilisez le bac à sable pour tous les développements, puis passez aux clés de production pour le live.

Étape 4 : Méthodes d'Authentification

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

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

Méthode 2 : Authentification par Signature HMAC 

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)
});
Enter fullscreen mode Exit fullscreen mode

HMAC signature

Traitement des Paiements : Points d'Accès Essentiels

Création d'une Commande Unique

Utilisez /orders pour créer une commande :

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 // Tokenisé côté client
    }
  };

  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

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"
}
Enter fullscreen mode Exit fullscreen mode

Gestion des Erreurs de Paiement

Toujours gérer les erreurs de manière spécifique :

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

  if (result.error) {
    switch (result.error.code) {
      case 'CARD_DECLINED':
        // Demander une carte différente au client
        break;
      case 'INSUFFICIENT_FUNDS':
        // Afficher un message adapté
        break;
      case 'INVALID_CVV':
        // Demander une nouvelle saisie du CVV
        break;
      default:
        // Log et message générique
        console.error('Payment failed:', result.error);
    }
  }
} catch (error) {
  // Erreur réseau ou serveur
  console.error('API request failed:', error);
}
Enter fullscreen mode Exit fullscreen mode

Codes d'Erreur Courants

Code d'Erreur Statut HTTP Description Résolution
CARD_DECLINED 402 Carte refusée Demander un autre mode de paiement
INVALID_CARD 400 Numéro de carte invalide Valider la saisie
EXPIRED_CARD 400 Carte expirée Demander une date d'expiration à jour
INVALID_CVV 400 Vérification CVV échouée Redemander le CVV
INSUFFICIENT_FUNDS 402 Fonds insuffisants Suggérer un autre paiement
DUPLICATE_ORDER 409 Commande déjà traitée Vérifier les doublons
INVALID_CURRENCY 400 Devise non prise en charge Vérifier le code devise
API_KEY_INVALID 401 Authentification échouée Vérifier la clé API

Gestion des Clients

Pour les achats récurrents, utilisez l'API client de 2Checkout.

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();
};
Enter fullscreen mode Exit fullscreen mode

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();
};
Enter fullscreen mode Exit fullscreen mode

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();
};
Enter fullscreen mode Exit fullscreen mode

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
};
Enter fullscreen mode Exit fullscreen mode

Remarque : Un client avec abonnements actifs ou soldes impayés ne peut être supprimé. Annulez d'abord les abonnements.

Modèles d'Intégration Avancés

Idempotence pour des Retentatives Sûres

Ajoutez X-Idempotency-Key sur chaque commande pour éviter les doublons :

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 par commande
    },
    body: JSON.stringify(payload)
  });

  return await response.json();
};

// Générer une clé unique par commande
const idempotencyKey = `order_${userId}_${Date.now()}`;
Enter fullscreen mode Exit fullscreen mode

Gestion de 3D Secure 2.0 (Conformité UE)

Pour la DSP2, activez 3DS :

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', // ou 'mandatory' pour l'UE
        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

Tarification Multi-Devises

Obtenez le prix localisé :

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

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

Prorata pour les Mises à Niveau d'Abonnement 

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

Dépannage des Problèmes Courants

Problème : Les Webhooks n'Arrivent Pas

Diagnostic :

// Vérifiez les logs de livraison webhook dans le dashboard 2Checkout
// Vérifiez les échecs ou les réponses non-200
Enter fullscreen mode Exit fullscreen mode

Solutions :

  1. Assurez-vous que votre endpoint retourne 200 OK en moins de 5 secondes
  2. Vérifiez l'HTTPS et le certificat SSL
  3. Liste blanche des IP 2Checkout dans le pare-feu
  4. Vérifiez la logique de signature webhook
  5. Testez avec un simulateur de webhook

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

Solutions :

  1. Vérifier l'utilisation des clés API du bac à sable
  2. Vérifier l'URL de base sandbox : https://sandbox.2checkout.com/api/
  3. Utiliser les bons numéros de carte de test
  4. Vérifier l'état du compte bac à sable

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

Diagnostic :

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

Solutions :

  1. Vérifier l'expiration de la carte du client
  2. Vérifier les paramètres de recouvrement
  3. Vérifier la livraison du webhook subscription.payment_failed
  4. Confirmer que auto_renew est activé

Problème : Discrépances de Conversion de Devise

Solutions :

  • Afficher une conversion « approximative » avec disclaimer
  • Bloquer le taux lors de la création du panier (15min)
  • Stocker les transactions dans la devise locale

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

Solutions :

  1. Utiliser la saisie semi-automatique d'adresses (Google Places, etc.)
  2. Rendre le code postal obligatoire
  3. Implémenter un AVS souple (avertir, ne pas refuser)
  4. Permettre au client de corriger l'adresse

Gestion des Abonnements

2Checkout facilite la facturation récurrente.

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',
    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

Mise à Jour d'un Abonnement 

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

Annulation d'un Abonnement 

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

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

Les webhooks permettent d'automatiser la gestion des événements sans polling.

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

  1. Accédez à Intégrations > Webhooks dans 2Checkout
  2. Ajoutez l'URL de votre endpoint HTTPS
  3. Sélectionnez les événements désirés
  4. 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;

  // Vérification de la 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());

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

  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

Événements Webhook Critiques

Type d'Événement Déclencheur Action Requise
order.created Nouvelle commande Envoyer un e-mail de confirmation
order.approved Paiement réussi Déclencher la livraison/l'accès
order.declined Paiement échoué Notifier le client, proposer relance
subscription.renewed Paiement récurrent Prolonger l'accès
subscription.payment_failed Renouvellement échoué Démarrer séquence de recouvrement
subscription.cancelled Annulation client Révoquer l'accès à la fin de période
refund.processed Remboursement émis Mettre à jour le solde utilisateur
chargeback.received Litige carte Préparer les preuves

Bonnes Pratiques des Webhooks

  1. Toujours vérifier les signatures (HMAC)
  2. Renvoyer 200 OK rapidement (évite les répétitions)
  3. Traiter en asynchrone (queue)
  4. Gérer l'idempotence (évite les doublons)
  5. Logger tous les événements

Test de Votre Intégration

Utilisation de l'Environnement de Bac à Sable 

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

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

// Adresse de test
const TEST_ADDRESS = {
  country: 'US',
  zip: '90210' // Déclenche AVS
};
Enter fullscreen mode Exit fullscreen mode

Test des Webhooks Localement 

# Installer ngrok
npm install -g ngrok

# Lancer votre serveur sur le port 3000
node server.js

# Exposer en public
ngrok http 3000

# Utiliser l'URL ngrok dans les paramètres webhook 2Checkout
Enter fullscreen mode Exit fullscreen mode

Apidog pour le Test d'API

Apidog facilite :

  1. Importer la spec OpenAPI de 2Checkout
  2. Créer des scénarios de test pour chaque point d'accès
  3. Simuler les réponses sans toucher l'API réelle
  4. Valider les webhooks et inspecter les payloads
  5. Partager avec votre équipe

Utilisez des variables d'environnement pour basculer rapidement entre bac à sable et production.

Liste de Contrôle du Déploiement en Production

Avant le passage en live :

  • [ ] Utiliser les clés API de production
  • [ ] Mettre à jour l'URL de base vers https://api.2checkout.com/
  • [ ] Activer la vérification de signature webhook
  • [ ] Configurer la surveillance des paiements échoués
  • [ ] Implémenter la logique de nouvelle tentative
  • [ ] Tester les flux de remboursement et rétrofacturation
  • [ ] Vérifier la conformité PCI DSS (tokenisation)
  • [ ] Activer 3DS 2.0 pour les clients UE
  • [ ] Mettre en place la journalisation/audit
  • [ ] Rédiger un guide opérationnel pour les incidents

Surveillance et Alertes

Surveillez vos taux de succès :

const successRate = approvedOrders / totalOrders * 100;

if (successRate < 95) {
  sendAlert('Le taux de succès des paiements est inférieur à 95%');
}

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

if (errorBreakdown['CARD_DECLINED'] > threshold) {
  sendAlert('Pics de refus de carte détectés');
}
Enter fullscreen mode Exit fullscreen mode

Cas d'Utilisation Réels

Intégration d'une Boutique E-commerce

Un détaillant de mode a intégré 2Checkout pour :

  • Plus de 100 devises supportées
  • Réduction de l'abandon panier de 23%
  • Gestion automatisée de la TVA UE
  • >2M$ de CA la première année

Démarrage via les pages de paiement hébergées, puis bascule vers l'API directe pour une UX personnalisée.

Entreprise d'Abonnement SaaS

Un SaaS de gestion de projet :

  • 5 000+ abonnements actifs
  • Prorata lors des upgrades de plan
  • Recouvrement automatisé lors des échecs
  • Réduction de l'attrition de 15% via relances intelligentes

Clé : accès basé sur les webhooks (subscription.renewed = prolongation, subscription.cancelled = révocation planifiée).

Conclusion

L'API 2Checkout fournit tous les outils pour gérer paiements et abonnements. Points d'action :

  • Développez/testez toujours sur le bac à sable
  • Vérifiez la signature HMAC des webhooks
  • Gérez les erreurs par code spécifique
  • Testez l'ensemble du cycle abonnement (essai, renouvellement, annulation)
  • Surveillez les métriques de paiement en production
  • Utilisez Apidog pour accélérer vos tests d'API

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, puis générez une nouvelle clé. Vous recevrez une clé privée (serveur) et une clé publique (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 sandbox dédié pour obtenir des clés API de test et simuler des transactions 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 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 avec HMAC-SHA256 et votre secret. Traitez les événements de manière asynchrone et retournez rapidement un 200 OK.

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 (en général 3 tentatives sur 7 jours) et un webhook subscription.cancelled si tout échoue.

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.

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

Oui. Le sandbox prend en charge l'intégralité du cycle de vie des abonnements (essais, renouvellements, upgrades, annulation). Utilisez la carte test 4111111111111111 pour simuler un paiement réussi.

Comment gérer les remboursements via l'API ?

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

Top comments (0)