Reverser de l'argent (retrait / déboursement)

Le déboursement vous permet d'envoyer de l'argent à un bénéficiaire par Mobile Money (Orange Money, Wave, MTN, Moov, Yas…) depuis votre solde Tchin. C'est l'opération inverse de l'encaissement : au lieu de recevoir un paiement, vous en émettez un. Il sert par exemple à payer des fournisseurs, à rembourser un client, à verser des gains ou à effectuer des reversements en masse.

Le retrait se déroule en deux appels — d'abord initier la demande, puis la soumettre pour exécution — auxquels s'ajoute un troisième appel facultatif pour vérifier le statut. Ce découpage vous laisse valider les informations (montant, bénéficiaire, pays débité) avant tout mouvement d'argent réel.

⚠️ Aucun mode test. Le déboursement est toujours réel et en environnement live : l'argent quitte votre solde et part chez le bénéficiaire. Vérifiez systématiquement le numéro, le montant et le solde du pays concerné avant de soumettre.

⏳ À LIRE ABSOLUMENT — un retrait peut rester « en attente » (pending), c'est normal. Certains opérateurs confirment le transfert en quelques secondes, d'autres en quelques minutes. pending n'est pas un échec. Votre application doit revérifier le statut final et le mettre à jour elle-même, sinon le retrait restera affiché « en attente » chez vous pour toujours — même s'il a réellement réussi. Voir Finaliser les retraits en attente.

Prérequis

Avant votre premier retrait, assurez-vous de réunir les conditions suivantes :

Un compte marchand vérifié avec une application API active (clés publique et secrète en main).
L'API de déboursement activée sur votre compte. C'est une fonctionnalité sensible : contactez le support Tchin si l'appel renvoie une erreur d'autorisation.
Un solde suffisant dans le pays correspondant au moyen de paiement choisi (voir la règle ci-dessous). Consultez d'abord votre solde par pays.
Le numéro du bénéficiaire, saisi sans l'indicatif pays (ex. 771234567 et non +221771234567).

Règle essentielle : le solde par pays

Votre solde Tchin n'est pas un pot commun : il est ventilé par pays. Chaque encaissement crédite le solde du pays où le paiement a eu lieu, et chaque retrait débite le solde du pays correspondant au withdraw_mode que vous fournissez.

Autrement dit, c'est le moyen de paiement qui détermine le pays débité. Par exemple :

wave-senegal ou orange-money-senegal → débite votre solde Sénégal.
t-money-togo ou moov-togo → débite votre solde Togo.
mtn-benin → débite votre solde Bénin.

Si le solde de ce pays est insuffisant, la demande est refusée dès l'initiation (HTTP 400) et aucun autre solde n'est touché. La liste complète des withdraw_mode et des pays associés se trouve sur la page Moyens de paiement.

Vue d'ensemble du flux

Étape	Appel	Effet sur le solde
1. Initier	`POST /disburse/initiate`	Aucun débit. La demande est enregistrée (statut interne `created`).
2. Soumettre	`POST /disburse/submit`	Débit du solde du pays à la réussite (idempotent).
3. Vérifier	`POST /disburse/status`	Aucun effet. Simple consultation.

Étape 1 — Initier le déboursement

Cet appel valide votre demande, identifie le pays à débiter à partir du withdraw_mode, vérifie que le solde de ce pays est suffisant, puis renvoie un disburse_token qui servira aux étapes suivantes. Rien n'est débité à ce stade : la demande passe simplement au statut interne created.

POST /api/v1/disburse/initiate

Champ	Type	Requis	Description
`account_alias`	texte (≤30)	oui	Numéro du bénéficiaire, sans indicatif pays (ex. `771234567`).
`amount`	entier	oui	Montant en FCFA (XOF, XAF au Cameroun). Pas de décimales, minimum 100.
`withdraw_mode`	texte (≤40)	oui	Code de l'opérateur. Détermine le pays débité. Voir Moyens de paiement.
`callback_url`	URL (≤500)	non	URL notifiée avec le résultat de la transaction. Fortement recommandée pour le suivi asynchrone.

Requête

curl -X POST https://tchin.tech/api/v1/disburse/initiate \
  -H "TCHIN-PUBLIC-KEY: tchin_pk_xxxxxxxx" \
  -H "TCHIN-PRIVATE-KEY: tchin_sk_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
        "account_alias": "771234567",
        "amount": 5000,
        "withdraw_mode": "wave-senegal",
        "callback_url": "https://monsite.com/tchin/disburse-callback"
      }'

<?php
// Étape 1 — Initier un déboursement
$ch = curl_init('https://tchin.tech/api/v1/disburse/initiate');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'TCHIN-PUBLIC-KEY: '.getenv('TCHIN_PUBLIC_KEY'),
        'TCHIN-PRIVATE-KEY: '.getenv('TCHIN_SECRET_KEY'),
        'Content-Type: application/json',
        'Accept: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'account_alias' => '771234567',        // bénéficiaire, SANS indicatif pays
        'amount'        => 5000,               // FCFA (XOF), entier
        'withdraw_mode' => 'wave-senegal',     // = code opérateur (détermine le pays débité)
        'callback_url'  => 'https://monsite.com/tchin/disburse-callback',
    ]),
]);
$res = json_decode(curl_exec($ch), true);
curl_close($ch);

if (empty($res['success'])) {
    // Ex : "Solde insuffisant sur le pays SN." ou "withdraw_mode non pris en charge."
    throw new RuntimeException($res['message'] ?? 'Erreur inconnue');
}

$disburseToken = $res['disburse_token'];   // à conserver pour l'étape 2
$country       = $res['country'];          // ex : "SN"

// Node.js 18+ (fetch natif) — Étape 1 : Initier
const r = await fetch('https://tchin.tech/api/v1/disburse/initiate', {
  method: 'POST',
  headers: {
    'TCHIN-PUBLIC-KEY': process.env.TCHIN_PUBLIC_KEY,
    'TCHIN-PRIVATE-KEY': process.env.TCHIN_SECRET_KEY,
    'Content-Type': 'application/json',
    'Accept': 'application/json',
  },
  body: JSON.stringify({
    account_alias: '771234567',        // bénéficiaire, SANS indicatif pays
    amount: 5000,                      // FCFA (XOF), entier
    withdraw_mode: 'wave-senegal',     // = code opérateur (détermine le pays débité)
    callback_url: 'https://monsite.com/tchin/disburse-callback',
  }),
});
const data = await r.json();

if (!data.success) {
  // Ex : "Solde insuffisant sur le pays SN." ou "withdraw_mode non pris en charge."
  throw new Error(data.message);
}

const disburseToken = data.disburse_token;   // à conserver pour l'étape 2
const country       = data.country;          // ex : "SN"

# Python (requests) — Étape 1 : Initier
import os, requests

r = requests.post('https://tchin.tech/api/v1/disburse/initiate',
    headers={
        'TCHIN-PUBLIC-KEY': os.environ['TCHIN_PUBLIC_KEY'],
        'TCHIN-PRIVATE-KEY': os.environ['TCHIN_SECRET_KEY'],
        'Accept': 'application/json',
    },
    json={
        'account_alias': '771234567',        # bénéficiaire, SANS indicatif pays
        'amount': 5000,                      # FCFA (XOF), entier
        'withdraw_mode': 'wave-senegal',     # = code opérateur (détermine le pays débité)
        'callback_url': 'https://monsite.com/tchin/disburse-callback',
    })
data = r.json()

if not data.get('success'):
    # Ex : "Solde insuffisant sur le pays SN." ou "withdraw_mode non pris en charge."
    raise RuntimeError(data.get('message'))

disburse_token = data['disburse_token']   # à conserver pour l'étape 2
country        = data['country']          # ex : "SN"

Réponse

{
  "success": true,
  "disburse_token": "hwTHAS0WvTmTaYT2zDoO",
  "country": "SN"
}

Champ	Description
`disburse_token`	Référence unique de la demande. Conservez-la : elle est requise pour soumettre et vérifier.
`country`	Code du pays déterminé à partir du `withdraw_mode`, dont le solde sera débité.

ℹ️ À la réception du disburse_token, la demande est seulement créée (statut created). Tant que vous n'appelez pas l'étape 2, aucun argent ne bouge. Vous pouvez donc abandonner une demande sans conséquence sur votre solde.

Erreurs fréquentes à l'initiation (HTTP 400)

Lorsque le solde du pays ne couvre pas le montant demandé, la réponse indique le solde disponible dans le champ balance :

Solde insuffisant

{
  "success": false,
  "message": "Solde insuffisant sur le pays SN.",
  "balance": 3000
}

Lorsque le withdraw_mode fourni n'existe pas ou n'est pas activé pour votre compte :

Opérateur non pris en charge

{
  "success": false,
  "message": "withdraw_mode non pris en charge."
}

Étape 2 — Soumettre pour exécution

Cet appel déclenche réellement le transfert chez l'opérateur, à partir du disburse_token obtenu à l'étape 1. Selon l'opérateur, la réponse est synchrone (résultat immédiat) ou asynchrone (traitement en arrière-plan).

POST /api/v1/disburse/submit — corps : { "disburse_token": "…" }

Requête

curl -X POST https://tchin.tech/api/v1/disburse/submit \
  -H "TCHIN-PUBLIC-KEY: tchin_pk_xxxxxxxx" \
  -H "TCHIN-PRIVATE-KEY: tchin_sk_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{ "disburse_token": "hwTHAS0WvTmTaYT2zDoO" }'

<?php
// Étape 2 — Exécuter le déboursement
$ch = curl_init('https://tchin.tech/api/v1/disburse/submit');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'TCHIN-PUBLIC-KEY: '.getenv('TCHIN_PUBLIC_KEY'),
        'TCHIN-PRIVATE-KEY: '.getenv('TCHIN_SECRET_KEY'),
        'Content-Type: application/json',
        'Accept: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'disburse_token' => $disburseToken,   // obtenu à l'étape 1
    ]),
]);
$res = json_decode(curl_exec($ch), true);
curl_close($ch);

if (($res['status'] ?? '') === 'success') {
    // Transfert abouti : le solde du pays a été débité.
    $transactionId = $res['transaction_id'];   // ex : "TCHIN-TX-..."
} elseif (($res['status'] ?? '') === 'pending') {
    // Traitement asynchrone : vérifiez le statut plus tard (étape 3).
}

// Node.js — Étape 2 : Exécuter
const r = await fetch('https://tchin.tech/api/v1/disburse/submit', {
  method: 'POST',
  headers: {
    'TCHIN-PUBLIC-KEY': process.env.TCHIN_PUBLIC_KEY,
    'TCHIN-PRIVATE-KEY': process.env.TCHIN_SECRET_KEY,
    'Content-Type': 'application/json',
    'Accept': 'application/json',
  },
  body: JSON.stringify({ disburse_token: disburseToken }),   // obtenu à l'étape 1
});
const data = await r.json();

if (data.status === 'success') {
  // Transfert abouti : le solde du pays a été débité.
  const transactionId = data.transaction_id;   // ex : "TCHIN-TX-..."
} else if (data.status === 'pending') {
  // Traitement asynchrone : vérifiez le statut plus tard (étape 3).
}

# Python — Étape 2 : Exécuter
import os, requests

r = requests.post('https://tchin.tech/api/v1/disburse/submit',
    headers={
        'TCHIN-PUBLIC-KEY': os.environ['TCHIN_PUBLIC_KEY'],
        'TCHIN-PRIVATE-KEY': os.environ['TCHIN_SECRET_KEY'],
        'Accept': 'application/json',
    },
    json={'disburse_token': disburse_token})   # obtenu à l'étape 1
data = r.json()

if data.get('status') == 'success':
    # Transfert abouti : le solde du pays a été débité.
    transaction_id = data['transaction_id']    # ex : "TCHIN-TX-..."
elif data.get('status') == 'pending':
    # Traitement asynchrone : vérifiez le statut plus tard (étape 3).
    pass

Réponse — succès immédiat

Le transfert a abouti. Votre solde du pays est débité à cet instant, et un transaction_id est renvoyé pour votre rapprochement comptable.

success

{
  "success": true,
  "status": "success",
  "message": "Success! Amount of 5000 FCFA transferred to 771234567.",
  "transaction_id": "TCHIN-TX-37XqPpVCjU7ReiycUg97"
}

Réponse — traitement asynchrone

Certains opérateurs traitent le transfert en arrière-plan. Le statut est alors pending : le résultat définitif vous parviendra via le callback_url, ou en interrogeant l'étape 3.

pending

{
  "success": true,
  "status": "pending",
  "message": "Déboursement en cours, vérifiez le statut."
}

✅ Le débit du solde n'intervient qu'à la réussite du transfert, et il est idempotent : soumettre plusieurs fois le même disburse_token ne débitera jamais votre solde deux fois.

Étape 3 — Vérifier le statut

À tout moment, interrogez l'état d'une demande avec son disburse_token. C'est indispensable après une réponse pending, mais aussi utile pour reconstituer l'historique d'un retrait.

POST /api/v1/disburse/status — corps : { "disburse_token": "…" }

Requête

curl -X POST https://tchin.tech/api/v1/disburse/status \
  -H "TCHIN-PUBLIC-KEY: tchin_pk_xxxxxxxx" \
  -H "TCHIN-PRIVATE-KEY: tchin_sk_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{ "disburse_token": "hwTHAS0WvTmTaYT2zDoO" }'

<?php
// Étape 3 — Vérifier le statut
$ch = curl_init('https://tchin.tech/api/v1/disburse/status');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'TCHIN-PUBLIC-KEY: '.getenv('TCHIN_PUBLIC_KEY'),
        'TCHIN-PRIVATE-KEY: '.getenv('TCHIN_SECRET_KEY'),
        'Content-Type: application/json',
        'Accept: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['disburse_token' => $disburseToken]),
]);
$res = json_decode(curl_exec($ch), true);
curl_close($ch);

// $res['status'] : created | pending | success | failed
echo $res['status'];

// Node.js — Étape 3 : Vérifier
const r = await fetch('https://tchin.tech/api/v1/disburse/status', {
  method: 'POST',
  headers: {
    'TCHIN-PUBLIC-KEY': process.env.TCHIN_PUBLIC_KEY,
    'TCHIN-PRIVATE-KEY': process.env.TCHIN_SECRET_KEY,
    'Content-Type': 'application/json',
    'Accept': 'application/json',
  },
  body: JSON.stringify({ disburse_token: disburseToken }),
});
const data = await r.json();

// data.status : created | pending | success | failed
console.log(data.status);

# Python — Étape 3 : Vérifier
import os, requests

r = requests.post('https://tchin.tech/api/v1/disburse/status',
    headers={
        'TCHIN-PUBLIC-KEY': os.environ['TCHIN_PUBLIC_KEY'],
        'TCHIN-PRIVATE-KEY': os.environ['TCHIN_SECRET_KEY'],
        'Accept': 'application/json',
    },
    json={'disburse_token': disburse_token})
data = r.json()

# data['status'] : created | pending | success | failed
print(data['status'])

Réponse

{
  "success": true,
  "status": "success"
}

Finaliser les retraits « en attente » (l'étape à ne pas oublier)

C'est l'oubli le plus fréquent lors d'une intégration. Quand un retrait revient pending à l'étape 2, votre application l'enregistre « en attente ». Mais le résultat définitif (réussi ou échoué) arrive un peu plus tard : si vous ne revérifiez jamais, ce retrait restera « en attente » indéfiniment dans votre système, alors qu'il a peut-être déjà réussi.

La solution — une tâche de fond dans VOTRE application : mettez en place un cron (ou une file d'attente) qui s'exécute toutes les 1 à 2 minutes, reprend tous vos retraits encore pending stockés en base, appelle POST /api/v1/disburse/status pour chacun avec son disburse_token, et met à jour leur statut chez vous : success → payé, failed → échoué (et vous re-créditez le client si besoin).

✅ Stockez toujours le disburse_token de chaque retrait dans votre base dès l'initiation : c'est la clé qui permet de rappeler son statut à tout moment.

<?php
// À EXÉCUTER PÉRIODIQUEMENT (cron toutes les 1-2 min, ou file d'attente).
// Reprend tous VOS retraits encore "pending" en base et met à jour leur statut.
function tchin_post($path, $body) {
    $ch = curl_init('https://tchin.tech/api/v1/'.$path);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true,
        CURLOPT_HTTPHEADER => [
            'TCHIN-PUBLIC-KEY: '.getenv('TCHIN_PUBLIC_KEY'),
            'TCHIN-PRIVATE-KEY: '.getenv('TCHIN_SECRET_KEY'),
            'Content-Type: application/json',
        ],
        CURLOPT_POSTFIELDS => json_encode($body),
    ]);
    return json_decode(curl_exec($ch), true);
}

// $pending = vos retraits en base avec statut 'pending' (et leur disburse_token stocké)
foreach ($pending as $retrait) {
    $res    = tchin_post('disburse/status', ['disburse_token' => $retrait['disburse_token']]);
    $status = $res['status'] ?? 'pending';   // created | pending | success | failed

    if ($status === 'success') {
        // -> marquez CE retrait comme PAYÉ dans VOTRE base
    } elseif ($status === 'failed') {
        // -> marquez ÉCHOUÉ (et re-créditez votre client si nécessaire)
    }
    // 'pending' / 'created' : encore en cours, on revérifiera au prochain passage
}

// À EXÉCUTER PÉRIODIQUEMENT (cron / worker toutes les 1-2 min).
async function tchinPost(path, body) {
  const r = await fetch('https://tchin.tech/api/v1/' + path, {
    method: 'POST',
    headers: {
      'TCHIN-PUBLIC-KEY': process.env.TCHIN_PUBLIC_KEY,
      'TCHIN-PRIVATE-KEY': process.env.TCHIN_SECRET_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(body),
  });
  return r.json();
}

// pending = vos retraits en base au statut 'pending' (avec disburse_token)
for (const retrait of pending) {
  const res    = await tchinPost('disburse/status', { disburse_token: retrait.disburse_token });
  const status = res.status;   // created | pending | success | failed

  if (status === 'success') {
    // -> marquez PAYÉ dans VOTRE base
  } else if (status === 'failed') {
    // -> marquez ÉCHOUÉ (re-créditez le client si nécessaire)
  }
  // pending / created : encore en cours, on revérifiera plus tard
}

# À EXÉCUTER PÉRIODIQUEMENT (cron toutes les 1-2 min).
import os, requests

def tchin_post(path, body):
    return requests.post('https://tchin.tech/api/v1/' + path, json=body, headers={
        'TCHIN-PUBLIC-KEY': os.environ['TCHIN_PUBLIC_KEY'],
        'TCHIN-PRIVATE-KEY': os.environ['TCHIN_SECRET_KEY'],
    }).json()

# pending = vos retraits en base au statut 'pending' (avec disburse_token)
for retrait in pending:
    res    = tchin_post('disburse/status', {'disburse_token': retrait['disburse_token']})
    status = res.get('status', 'pending')   # created | pending | success | failed

    if status == 'success':
        pass   # -> marquez PAYÉ dans VOTRE base
    elif status == 'failed':
        pass   # -> marquez ÉCHOUÉ (re-créditez le client si nécessaire)
    # pending / created : encore en cours, on revérifiera plus tard

Concrètement : un simple script planifié qui tourne en boucle sur vos retraits non finalisés suffit. Une fois en place, plus aucun retrait ne reste bloqué « en attente » chez vous.

Statuts possibles et conduite à tenir

Statut	Signification	Que faire
`created`	Demande initiée mais pas encore soumise.	Appelez l'étape 2 (`submit`) pour l'exécuter.
`pending`	Soumise, en cours de traitement chez l'opérateur.	Patientez et réinterrogez l'étape 3 périodiquement jusqu'à un statut final.
`success`	Transfert abouti. Votre solde du pays a été débité.	Rien de plus. Archivez le `transaction_id`.
`failed`	Le transfert a échoué. Aucun débit n'a eu lieu.	Vérifiez le numéro et l'opérateur, puis relancez une nouvelle demande si besoin.

Exemple complet : enchaîner initiate → submit → status

Voici un exemple de bout en bout qui initie un retrait, le soumet, puis boucle sur la vérification tant que le statut reste pending. Les clés API restent strictement côté serveur (variables d'environnement).

<?php
// Exemple complet : initiate -> submit -> (si pending) status
// Les clés vivent UNIQUEMENT côté serveur (variables d'environnement).

function tchin_post(string $path, array $body): array {
    $ch = curl_init('https://tchin.tech/api/v1/'.$path);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST           => true,
        CURLOPT_HTTPHEADER     => [
            'TCHIN-PUBLIC-KEY: '.getenv('TCHIN_PUBLIC_KEY'),
            'TCHIN-PRIVATE-KEY: '.getenv('TCHIN_SECRET_KEY'),
            'Content-Type: application/json',
            'Accept: application/json',
        ],
        CURLOPT_POSTFIELDS => json_encode($body),
    ]);
    $res = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $res ?? [];
}

// 1) Initier
$init = tchin_post('disburse/initiate', [
    'account_alias' => '771234567',
    'amount'        => 5000,
    'withdraw_mode' => 'wave-senegal',
    'callback_url'  => 'https://monsite.com/tchin/disburse-callback',
]);

if (empty($init['success'])) {
    exit('Initiation refusée : '.($init['message'] ?? '?'));
}
$token = $init['disburse_token'];

// 2) Soumettre pour exécution
$run = tchin_post('disburse/submit', ['disburse_token' => $token]);

// 3) Boucle de vérification si l'opérateur répond en asynchrone
if (($run['status'] ?? '') === 'pending') {
    do {
        sleep(5);
        $check = tchin_post('disburse/status', ['disburse_token' => $token]);
        $status = $check['status'] ?? 'pending';
    } while ($status === 'pending' || $status === 'created');
    echo "Statut final : $status";
} else {
    echo "Statut : ".($run['status'] ?? '?');
}

// Exemple complet : initiate -> submit -> (si pending) status
const BASE = 'https://tchin.tech/api/v1';

async function tchinPost(path, body) {
  const r = await fetch(`${BASE}/${path}`, {
    method: 'POST',
    headers: {
      'TCHIN-PUBLIC-KEY': process.env.TCHIN_PUBLIC_KEY,
      'TCHIN-PRIVATE-KEY': process.env.TCHIN_SECRET_KEY,
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
    body: JSON.stringify(body),
  });
  return r.json();
}

const sleep = (ms) => new Promise((res) => setTimeout(res, ms));

// 1) Initier
const init = await tchinPost('disburse/initiate', {
  account_alias: '771234567',
  amount: 5000,
  withdraw_mode: 'wave-senegal',
  callback_url: 'https://monsite.com/tchin/disburse-callback',
});
if (!init.success) throw new Error('Initiation refusée : ' + init.message);
const token = init.disburse_token;

// 2) Soumettre pour exécution
const run = await tchinPost('disburse/submit', { disburse_token: token });

// 3) Boucle de vérification si l'opérateur répond en asynchrone
let status = run.status;
while (status === 'pending' || status === 'created') {
  await sleep(5000);
  const check = await tchinPost('disburse/status', { disburse_token: token });
  status = check.status;
}
console.log('Statut final :', status);

Bonnes pratiques

Vérifiez votre solde avant d'initier pour éviter les refus. Consultez la page Solde.
Choisissez le bon withdraw_mode : c'est lui qui fixe le pays débité. La liste exhaustive est sur la page Moyens de paiement.
Sur un statut pending, interrogez le statut périodiquement (toutes les quelques secondes) jusqu'à obtenir success ou failed ; ne considérez jamais un pending comme abouti.
Conservez le disburse_token et le transaction_id de chaque opération pour votre rapprochement comptable et le support.
Fournissez un callback_url pour être notifié automatiquement du résultat sans avoir à interroger l'API en boucle.
Consultez la page Erreurs & statuts pour la liste complète des codes HTTP et des messages métier.

Reverser de l'argent (retrait / déboursement)

Prérequis

Règle essentielle : le solde par pays

Vue d'ensemble du flux

Étape 1 — Initier le déboursement

Requête

Réponse

Erreurs fréquentes à l'initiation (HTTP 400)

Étape 2 — Soumettre pour exécution

Requête

Réponse — succès immédiat

Réponse — traitement asynchrone

Étape 3 — Vérifier le statut

Requête

Réponse

Finaliser les retraits « en attente » (l'étape à ne pas oublier)

Statuts possibles et conduite à tenir

Exemple complet : enchaîner initiate → submit → status

Bonnes pratiques

Connexion / Inscription

Entrez le code