Documentation API CryptoGate

CryptoGate te permet d'accepter des paiements en cryptomonnaie et par carte bancaire sur ton site ou ton application. Tu peux utiliser notre checkout hébergé (le plus simple) ou construire ta propre interface en interrogeant l'API des moyens disponibles pour ta clé, puis en créant un paiement et en redirigeant vers les URLs documentées.

Authentification

Toutes les requêtes API nécessitent un token Bearer. Tu peux créer tes clés API depuis le dashboard.

Authorization: Bearer cgk_your_api_key_here

URL de base

https://crypto-gate.cc

Toutes les routes documentées ici sont relatives à cette URL.

Créer un paiement

Body (JSON)

Réponse (201 Created)

{
  "paymentId": "a1b2c3d4-5678-...",
  "checkoutUrl": "https://crypto-gate.cc/checkout/a1b2c3d4-5678-..."
}

Flux d'intégration recommandé

1. Crée ta commande dans ta base de données (produit, montant, statut "en attente", etc.) et génère un orderId unique
2. Appelle notre API avec cet orderId + le montant et l'email du client
3. Redirige ton client (HTTP 302 ou JavaScript) vers le checkoutUrl retourné
4. Le client paye sur notre page hébergée (carte ou crypto)
5. Tu reçois un webhook POST sur ta callbackUrl contenant le orderId et le nouveau statut
6. Retrouve ta commande par orderId dans ta DB et mets-la à jour (activée, livrée, etc.)

// 1. Créer la commande dans ta DB
app.post('/buy', async (req, res) => {
  const order = await db.orders.create({
    product: req.body.product,
    amount: 49.99,
    currency: 'EUR',
    email: req.body.email,
    status: 'pending',           // En attente de paiement
  });

  // 2. Créer le paiement chez CryptoGate
  const response = await fetch('https://crypto-gate.cc/api/payment-links', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer ' + process.env.CRYPTOGATE_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      amount: order.amount,
      currency: order.currency,
      email: order.email,
      orderId: order.id,         // ← Ton identifiant unique
      label: 'Commande #' + order.id,
    }),
  });
  const { checkoutUrl } = await response.json();

  // 3. Rediriger le client vers le checkout
  res.redirect(checkoutUrl);
});

// 5. Recevoir le webhook quand le paiement est confirmé
app.post('/webhook/cryptogate', express.raw({ type: 'application/json' }), (req, res) => {
  const event = JSON.parse(req.body);

  if (event.event === 'payment.paid') {
    // 6. Retrouver la commande par orderId et la valider
    await db.orders.update(
      { id: event.payment.orderId },
      { status: 'paid' }
    );
    // → Activer l'abonnement, envoyer le produit, etc.
  }

  res.sendStatus(200);
});

Statuts de paiement

Flux checkout

La page checkout hébergée gère tout le processus de paiement :

1. Sélection — le client choisit entre carte bancaire et cryptomonnaie
2. Carte bancaire — redirection vers le prestataire (RampNetwork) qui convertit le fiat en crypto
3. Crypto directe — affichage d'un QR code + adresse wallet + montant exact en crypto
4. Confirmation — page de succès ou d'erreur, puis callback vers ton serveur

Les cryptomonnaies disponibles et le branding sont configurés dans ton dashboard pour chaque clé API.

Moyens de paiement disponibles (checkout personnalisé)

Pour afficher les mêmes options que notre page checkout, sans deviner la configuration de ta clé, appelle cette route avec le même Authorization: Bearer que pour créer un paiement.

Query (optionnelle)

Si tu omets les deux, la réponse liste les moyens configurés pour ta clé sans appliquer les minimums (utile pour une page « nous acceptons… »). Si tu passes l’un sans l’autre, tu reçois une erreur 400. Avec amount et currency, les champs methodsUnavailable et crypto.coinsBelowMinimum reflètent le même comportement que le checkout hébergé.

Réponse (200)

La réponse inclut notamment :

• methods — moyens sélectionnables (fiat ou agrégat crypto), avec paygateProvider pour le fiat direct vers PayGate
• methodsUnavailable — moyens sous le minimum configuré
• crypto.coins / crypto.coinsBelowMinimum — détail par actif (providerForApi au format crypto:coinId, aligné sur les webhooks)

L’ordre des entrées dans methods suit celui défini pour ta clé dans le dashboard (Clé API → Moyens de paiement), puis la liste globale de la plateforme si tu n’as rien personnalisé.

Après POST /api/payment-links, les chemins hébergés sont du type /checkout/{paymentId}/pay/{methodId}, /checkout/{paymentId}/crypto et /checkout/{paymentId}/crypto/{coinId} (préfixe = URL de base du service).

const r = await fetch('https://crypto-gate.cc/api/payment-methods?amount=49.99&currency=EUR', {
  headers: { 'Authorization': 'Bearer ' + process.env.CRYPTOGATE_KEY },
});
const data = await r.json();
// data.methods → boutons fiat / crypto
// data.crypto.coins → liste des actifs pour liens /checkout/{paymentId}/crypto/{coinId}

Webhooks — Vue d'ensemble

Les webhooks te permettent de recevoir automatiquement une notification quand un paiement change de statut. CryptoGate envoie un POST JSON vers la callbackUrl configurée sur ta clé API.

Comment ça marche

1. Un paiement change de statut (pending → confirming → paid)
2. CryptoGate envoie un POST à ta callbackUrl avec le payload JSON
3. Ton serveur vérifie la signature (optionnel mais recommandé) et traite l'événement
4. Ton serveur répond 200 OK

Le status checker vérifie aussi les paiements pending toutes les 5 minutes pendant 1 heure après leur création, pour détecter les changements même si le callback initial n'arrive pas.

Extension WooCommerce

L’extension WooCommerce te permet d’intégrer CryptoGate sans développer : au clic “Commander”, WooCommerce crée un paiement via l’API puis redirige le client vers le checkout hébergé. La commande est validée automatiquement via webhook (recommandé).

1) Télécharger et installer

1. Depuis le dashboard CryptoGate : Extensions → WooCommerce → Télécharger le plugin
2. Sur WordPress : Extensions → Ajouter → Téléverser → active le plugin

2) Configurer WooCommerce

WooCommerce → Réglages → Paiements → CryptoGate :

3) Webhook (recommandé)

CryptoGate envoie les webhooks vers la callbackUrl configurée sur ta clé API. Pour WooCommerce, la callback URL est :

https://ton-site.com/wp-json/cryptogate/v1/webhook

Flux technique

1. WooCommerce appelle POST /api/payment-links avec orderId, amount, currency, email
2. CryptoGate renvoie checkoutUrl
3. Le client est redirigé vers checkoutUrl
4. À la confirmation du paiement, CryptoGate envoie un webhook vers WordPress

Format du payload

{
  "event": "payment.paid",
  "timestamp": "2026-02-07T10:30:00.000Z",
  "payment": {
    "id": "a1b2c3d4-5678-...",
    "orderId": "order-123",
    "amount": 49.99,
    "currency": "EUR",
    "status": "paid",
    "provider": "crypto:polygon-usdt",
    "createdAt": "2026-02-07T10:00:00.000Z"
  }
}

Champs du payload

Headers envoyés

Champ provider

Vérification de signature HMAC

Pour garantir que le webhook provient bien de CryptoGate, tu peux activer la signature HMAC-SHA256 dans le dashboard. Chaque requête contiendra un header X-Webhook-Signature.

Algorithme

1. Lis le body brut de la requête (string JSON, avant le parsing)
2. Calcule HMAC-SHA256(body, ton_secret)
3. Compare avec la valeur après sha256= dans le header

import crypto from 'crypto';

function verifySignature(rawBody, signature, secret) {
  const expected = 'sha256=' + crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

// Dans ton handler Express :
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['x-webhook-signature'];
  if (!verifySignature(req.body, sig, process.env.WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }
  const event = JSON.parse(req.body);
  // Traiter l'événement…
  res.sendStatus(200);
});

import hmac, hashlib

def verify_signature(raw_body: bytes, signature: str, secret: str) -> bool:
    expected = 'sha256=' + hmac.new(
        secret.encode(), raw_body, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected)

$payload = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? '';
$expected = 'sha256=' . hash_hmac('sha256', $payload, $webhookSecret);

if (!hash_equals($expected, $signature)) {
    http_response_code(401);
    exit('Invalid signature');
}

Événements webhook

Retry & bonnes pratiques

• Timeout : 10 secondes max pour répondre
• Code attendu : 2xx pour confirmer la réception
• Retry manuel : les webhooks échoués peuvent être renvoyés depuis le dashboard (onglet Webhooks de ta clé)
• Status checker : en plus des webhooks, CryptoGate vérifie les paiements toutes les 5 minutes pendant 1h — si un changement est détecté, un nouveau webhook est envoyé
• HTTPS : utilise toujours une URL HTTPS pour ta callback

Exemple — Node.js

const response = await fetch('https://crypto-gate.cc/api/payment-links', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer cgk_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    amount: 49.99,
    currency: 'EUR',
    email: 'client@example.com',
    orderId: 'order-12345',
    label: 'Abonnement Premium',
  }),
});

const data = await response.json();
console.log(data.checkoutUrl);
// → Redirige le client vers data.checkoutUrl

Exemple — Python

import requests

resp = requests.post(
    'https://crypto-gate.cc/api/payment-links',
    headers={'Authorization': 'Bearer cgk_your_api_key'},
    json={
        'amount': 49.99,
        'currency': 'EUR',
        'email': 'client@example.com',
        'orderId': 'order-12345',
        'label': 'Abonnement Premium',
    }
)

data = resp.json()
print(data['checkoutUrl'])
# → Redirige le client vers data['checkoutUrl']

Exemple — PHP

$ch = curl_init('https://crypto-gate.cc/api/payment-links');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer cgk_your_api_key',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'amount' => 49.99,
        'currency' => 'EUR',
        'email' => 'client@example.com',
        'orderId' => 'order-12345',
        'label' => 'Abonnement Premium',
    ]),
]);

$response = curl_exec($ch);
$data = json_decode($response, true);
// Rediriger : header('Location: ' . $data['checkoutUrl']);

Exemple — cURL

curl -X POST https://crypto-gate.cc/api/payment-links \
  -H "Authorization: Bearer cgk_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 49.99,
    "currency": "EUR",
    "email": "client@example.com",
    "orderId": "order-12345"
  }'

Codes d'erreur

Toutes les erreurs retournent un JSON avec un champ error :

{
  "error": "Champs requis manquants: amount, orderId"
}

Limites

Des limites de requêtes sont appliquées par IP pour protéger la plateforme. En cas de dépassement, vous recevrez un code 429 Too Many Requests.

Autres informations :

• Les webhooks timeout après 10 secondes
• Les webhooks échoués sont réessayés jusqu'à 5 fois avec un backoff exponentiel
• Le status checker vérifie les paiements pending pendant 1 heure maximum