SDK de tokenisation : intégrer PCI Proxy EU en Node.js, Python et PHP

L'intégration de la tokenisation PCI Proxy EU dans votre stack applicatif est conçue pour être aussi simple que possible pour les développeurs. Que vous travailliez en Node.js, Python ou PHP, l'API REST PCI Proxy EU suit des conventions standard, et les SDKs disponibles permettent de démarrer en quelques lignes de code — sans jamais manipuler de données de carte dans votre code.

Architecture de l'intégration : le principe fondamental

Le principe architectural fondamental de PCI Proxy EU est que votre code backend ne doit jamais voir un PAN. Tout le SDK est conçu autour de cette contrainte. Pour les paiements en ligne, les données de carte sont capturées via les hosted payment fields (composants JavaScript sécurisés hébergés par PCI Proxy EU) — votre frontend reçoit un token temporaire qu'il transmet à votre backend. Pour les API server-to-server (paiements récurrents, MOTO avec DTMF), les PAN sont tokenisés à leur point d'entrée dans le système PCI Proxy EU et vous ne recevez que des tokens persistants.

En pratique, cela signifie que votre code backend travaille exclusivement avec des tokens. La seule interaction avec l'API PCI Proxy EU depuis votre backend est l'initiation de transactions (en transmettant un token, un montant et les paramètres PSP) et éventuellement la gestion du cycle de vie des tokens (révocation, mise à jour). Votre code ne fait jamais de requête qui retourne un PAN — les PAN ne sortent jamais du vault vers votre infrastructure.

Intégration en Node.js

L'intégration Node.js de PCI Proxy EU s'effectue via le SDK npm @pci-proxy-eu/sdk ou directement via l'API REST avec la bibliothèque axios ou fetch. Voici un exemple d'initiation de transaction récurrente :

const { PCIProxyClient } = require('@pci-proxy-eu/sdk');

const client = new PCIProxyClient({
  apiKey: process.env.PCI_PROXY_API_KEY,
  environment: 'production'
});

async function chargeRecurring(tokenId, amount, currency) {
  const result = await client.transactions.create({
    token: tokenId,
    amount: amount,
    currency: currency,
    pspId: 'stripe-eu',
    transactionType: 'recurring'
  });

  return result.transactionId;
}

Remarquez qu'à aucun moment votre code Node.js ne manipule un PAN. La variable tokenId est un token PCI Proxy EU opaque. La réponse de l'API ne contient pas de PAN — elle contient un identifiant de transaction et le résultat de l'autorisation. Votre serveur Node.js reste hors du CDE PCI DSS.

Intégration en Python

Le SDK Python pci-proxy-eu suit les mêmes conventions que le SDK Node.js. Il est installable via pip et compatible Python 3.8+. Voici un exemple de gestion d'un abonnement avec le SDK Python :

from pci_proxy_eu import PCIProxyClient, TransactionRequest

client = PCIProxyClient(
    api_key=os.environ['PCI_PROXY_API_KEY'],
    environment='production'
)

def process_subscription_renewal(token_id: str, plan: dict) -> str:
    request = TransactionRequest(
        token=token_id,
        amount=plan['amount'],
        currency=plan['currency'],
        psp_id=plan['psp_id'],
        transaction_type='recurring',
        metadata={'subscription_id': plan['id']}
    )

    result = client.transactions.create(request)
    return result.transaction_id

Le SDK Python gère automatiquement la sérialisation/désérialisation JSON, les retries sur erreurs réseau transitoires et l'authentification via API key. Les erreurs PCI Proxy EU sont mappées sur des exceptions Python typées, facilitant la gestion des cas d'erreur (carte refusée, PSP indisponible, token invalide).

Intégration en PHP

Le SDK PHP pci-proxy-eu/sdk est compatible PHP 7.4+ et PHP 8.x. Il s'installe via Composer et s'intègre nativement avec les frameworks populaires (Laravel, Symfony, WordPress avec WooCommerce). Voici un exemple d'intégration avec Laravel :

use PCIProxyEU\Client;
use PCIProxyEU\Requests\TransactionRequest;

class PaymentService {
    private Client $client;

    public function __construct() {
        $this->client = new Client([
            'api_key' => config('pci_proxy.api_key'),
            'environment' => config('pci_proxy.environment')
        ]);
    }

    public function chargeToken(string $token, int $amount, string $currency): array {
        $request = new TransactionRequest([
            'token' => $token,
            'amount' => $amount,
            'currency' => $currency,
            'psp_id' => config('pci_proxy.default_psp')
        ]);

        return $this->client->transactions()->create($request)->toArray();
    }
}

Environnement sandbox et bonnes pratiques de test

PCI Proxy EU fournit un environnement sandbox complet pour tester vos intégrations sans utiliser de vraies données de carte. En sandbox, vous pouvez utiliser les PANs de test standard (Visa 4242424242424242, Mastercard 5555555555554444) pour générer des tokens de test, initier des transactions simulées et tester les scénarios d'erreur (carte refusée, expirée, fonds insuffisants).

La bonne pratique est d'utiliser des variables d'environnement pour gérer les clés API et l'environnement (sandbox vs production), de ne jamais hard-coder de clé API dans le code source, et d'utiliser des données de test dans tous vos environnements non-production. Ces pratiques sont exigées par PCI DSS (exigence 6.3.2 sur la revue du code applicatif et 8.6.3 sur la gestion des secrets) — elles améliorent également la sécurité générale de votre application.

Questions fréquentes

Vous souhaitez démarrer l'intégration du SDK PCI Proxy EU dans votre application ? Accédez à la documentation technique.