Tokenisierungs-SDK: PCI Proxy EU in Node.js, Python und PHP integrieren

Die Integration von PCI-DSS-Tokenisierung in eine Zahlungsanwendung erfordert nicht wochenlange Entwicklungsarbeit. Das PCI Proxy EU SDK bietet dokumentierte Client-Bibliotheken für die gängigsten Backend-Sprachen und ermöglicht es Entwicklern, Token-Flüsse sicher ohne direkte PAN-Verwaltung zu implementieren. Dieser Leitfaden zeigt die wichtigsten Integrationsschritte für Node.js, Python und PHP mit vollständig PCI-konformen API-Aufrufen.

Warum die Backend-Integration keine PAN sehen sollte

Das grundlegende Designprinzip für eine PCI-konforme Integration ist: Die PAN darf niemals durch den Backend-Code des Händlers gehen. Wenn das Zahlungsformular auf der Client-Seite (Browser oder App) ist, sollen Kartendaten direkt an den PCI Proxy EU Vault übertragen werden – über das clientseitige JavaScript-SDK oder eine gehostete Zahlungsseite –, ohne den Server des Händlers zu durchqueren. Der Server empfängt nur den Token.

Diese Trennung hat direkte Auswirkungen auf den PCI-Scope: Wenn keine PAN den Server berührt, fällt der Server nicht in die CDE. Das bedeutet keine Verschlüsselungspflichten für Datenbanken, keine ASV-Scans für diesen Server, keine spezifischen Zugangskontrollrichtlinien für Zahlungsdaten. Das Backend verwendet den Token, um Transaktionen zu initiieren, und nur der PCI Proxy EU Vault verwaltet den tatsächlichen Zugang zur PAN.

Node.js Integration: Token-basierte Zahlung initiieren

Das Backend-Beispiel zeigt, wie eine Zahlung über PCI Proxy EU mit einem Token initiiert wird, den der Client zuvor erhalten hat:

// PCI Proxy EU Node.js Integration
const axios = require('axios');

async function processPayment(token, amount, currency) {
  const response = await axios.post(
    'https://api.pci-proxy.eu/v1/charge',
    {
      token: token,           // Token vom Client erhalten
      amount: amount,         // in Cent (z.B. 1000 = 10,00 EUR)
      currency: currency,     // ISO 4217 (z.B. 'EUR')
      merchantId: process.env.PCI_PROXY_MERCHANT_ID,
    },
    {
      headers: {
        'Authorization': `Bearer ${process.env.PCI_PROXY_API_KEY}`,
        'Content-Type': 'application/json',
      },
    }
  );
  
  return response.data; // { transactionId, status, authCode }
}

// Verwendung
app.post('/checkout', async (req, res) => {
  const { token, amount } = req.body; // PAN niemals hier
  const result = await processPayment(token, amount, 'EUR');
  res.json({ success: true, transactionId: result.transactionId });
});

Python Integration: Token-basierte Belastung

# PCI Proxy EU Python Integration
import requests
import os

def process_payment(token: str, amount: int, currency: str) -> dict:
    """
    Initiiert eine Belastung über PCI Proxy EU.
    Kein PAN in diesem Code: nur sichere Token-Verwaltung.
    """
    response = requests.post(
        'https://api.pci-proxy.eu/v1/charge',
        json={
            'token': token,
            'amount': amount,
            'currency': currency,
            'merchantId': os.environ['PCI_PROXY_MERCHANT_ID'],
        },
        headers={
            'Authorization': f"Bearer {os.environ['PCI_PROXY_API_KEY']}",
            'Content-Type': 'application/json',
        },
        timeout=30
    )
    response.raise_for_status()
    return response.json()

# Django/Flask View Beispiel
def checkout_view(request):
    token = request.POST.get('token')  # Vom Client, keine PAN
    amount = int(request.POST.get('amount'))
    
    result = process_payment(token, amount, 'EUR')
    return JsonResponse({'success': True, 'id': result['transactionId']})

PHP Integration: Abonnementzahlung mit Token

<?php
// PCI Proxy EU PHP Integration
class PciProxyClient {
    private string $apiKey;
    private string $merchantId;
    private string $baseUrl = 'https://api.pci-proxy.eu/v1';
    
    public function __construct(string $apiKey, string $merchantId) {
        $this->apiKey = $apiKey;
        $this->merchantId = $merchantId;
    }
    
    public function charge(string $token, int $amount, string $currency): array {
        // Keine PAN hier: nur Token und Betrag
        $ch = curl_init($this->baseUrl . '/charge');
        $payload = json_encode([
            'token' => $token,
            'amount' => $amount,
            'currency' => $currency,
            'merchantId' => $this->merchantId,
        ]);
        
        curl_setopt_array($ch, [
            CURLOPT_POST => true,
            CURLOPT_POSTFIELDS => $payload,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json',
            ],
        ]);
        
        $response = curl_exec($ch);
        curl_close($ch);
        return json_decode($response, true);
    }
}

// Abonnementverlängerung mit gespeichertem Token
$client = new PciProxyClient($_ENV['PCI_PROXY_API_KEY'], $_ENV['MERCHANT_ID']);
$token = $db->getTokenForSubscription($subscriptionId); // Gespeicherter Token, keine PAN
$result = $client->charge($token, 1999, 'EUR');
?>

Häufig gestellte Fragen

Bereit, mit der Integration zu beginnen? Greifen Sie auf die PCI Proxy EU Dokumentation zu. Entdecken Sie PCI Proxy EU.