Intégrez les paiements Mobile Money simplement.
Un guide complet et pratique pour connecter votre backend à CamerPay, lancer des dépôts et retraits, recevoir les résultats et consulter vos rapports.
https://api.camerpay.net/applicationAPI_PAY
servicetransaction
actiondepot
token••••••••••••••••
{ "etat": true, "data": { "replyTo": "…" } }
DÉMARRAGE RAPIDE
Votre premier appel en quelques minutes
Tous les appels partent de votre serveur. Conservez les identifiants et le token dans un environnement backend sécurisé.
Préparez vos accès
Récupérez votre numéro de compte API, votre mot de passe et une URL HTTPS publique pour le callback.
Connectez-vous
Appelez authentification/login et stockez le token retourné uniquement côté serveur.
Configurez le callback
Enregistrez votre URL avec account/change_callback avant toute transaction asynchrone.
Lancez puis attendez
Enregistrez le replyTo reçu avec le statut 202, puis attendez le callback pour le résultat final.
Il confirme seulement que CamerPay a accepté la demande. Utilisez le callback avec etat=true ou etat=false comme résultat final.
curl --request GET 'https://api.camerpay.net/' \
--header 'id: login-001' \
--header 'langue: FR' \
--header 'application: API_PAY' \
--header 'service: authentification' \
--header 'action: login' \
--header 'DATA: {"numero":"6XXXXXXXX","pass":"VOTRE_MOT_DE_PASSE"}'
CONTRAT DE BASE
Format des requêtes et réponses
L’API utilise une URL unique. Le service et l’action sont sélectionnés dans les en-têtes HTTP. Lorsque DATA est requis, envoyez un objet JSON converti en chaîne de caractères.
| En-tête | Obligatoire | Description | Exemple |
|---|---|---|---|
id | Oui | Identifiant unique de votre requête. | req-20260730-001 |
langue | Oui | Langue des messages retournés. | FR / EN |
application | Oui | Application appelée. | API_PAY |
service | Oui | Famille de l’opération. | transaction |
action | Oui | Opération précise. | depot |
token | Selon l’action | Authentifie le compte API. | VOTRE_TOKEN |
DATA | Selon l’action | Objet JSON sérialisé en texte. | {"montant":5000} |
{
"etat": true,
"id": "balance-001",
"token": "VOTRE_TOKEN",
"service": "account",
"action": "balance",
"message": "Solde récupéré avec succès.",
"data": {
"credit": 125000
}
}
Comment lire la réponse
etat- Succès ou échec logique de l’opération.
id- L’identifiant fourni dans votre requête.
message- Résumé lisible du résultat.
data- Les données utiles propres à l’action.
AUTH
Authentification
login
Connexion avec le numéro du compte et le mot de passe. Le token est retourné à la racine de la réponse.
token
Crée une nouvelle session avec un token existant, notamment au démarrage du service ou après un HTTP 401.
inscription + validation
Crée un compte puis valide le code reçu avec le token provisoire. Suivez strictement cet ordre.
Une session inactive expire après environ 15 minutes. En cas de HTTP 401, recréez une session avec authentification/token avant de rejouer une requête sûre.
COMPTE
Gestion du compte
balance
Retourne le crédit CamerPay disponible dans data.credit.
change_callback
Enregistre une URL HTTPS publique. Les adresses locales, privées et les fragments # sont refusés.
change_token
Génère un nouveau token dans data.token. Remplacez immédiatement l’ancien secret.
PAIEMENTS
Transactions asynchrones
L’identification, le dépôt et le retrait suivent le même principe : la requête initiale retourne un identifiant de suivi, puis le résultat définitif arrive plus tard sur votre callback.
etat=true/falseIdentifier un numéro
Vérifie un numéro camerounais avant une opération et retourne le nom identifié dans le callback.
{"numero":"6XXXXXXXX"}Effectuer un dépôt
Envoie de la valeur vers le compte Mobile Money du client.
{"numeroClient":"6XXXXXXXX","montant":5000}Effectuer un retrait
Initie un retrait depuis le compte Mobile Money du client.
{"numeroClient":"6XXXXXXXX","montant":5000}Exactement 9 chiffres, commence par 6, sans +237. Le réseau Orange ou MTN est détecté automatiquement.
Entre 500 et 500 000 FCFA pour un dépôt ou un retrait.
PENDING → PROCESSING → SUCCESS / FAILED
WEBHOOK
Recevoir le résultat final
CamerPay envoie une requête POST JSON vers l’URL enregistrée. Utilisez replyTo pour rapprocher le callback de la demande initiale et rendez le traitement idempotent.
{
"id": "notification-uuid",
"replyTo": "ID-DE-SUIVI-CAMERPAY",
"type": "EVENT",
"application": "CamPay",
"service": "notification",
"action": "",
"etat": true,
"message": null,
"data": {
"date": "2026-07-30T12:30:00.000",
"numero": "6XXXXXXXX",
"title": "CamPay",
"message": "Dépôt effectué avec succès.",
"id": 102
}
}
Traitement recommandé
- Vérifier que replyTo existe et que type vaut EVENT.
- Retrouver votre transaction à partir de replyTo.
- Ignorer sans erreur un événement déjà traité.
- Passer à SUCCESS si etat=true, sinon à FAILED.
- Conserver le callback brut pour l’audit.
- Répondre rapidement avec HTTP 200 ou 201.
HISTORIQUE
Rapports et réconciliation
Le service rapport permet de consulter les transactions et les notifications de votre compte. Utilisez-le pour vos écrans d’historique et pour la réconciliation.
rapport / transactionHistorique des dépôts, retraits et autres opérations.
{"limit":10,"id":86}rapport / notificationHistorique des événements et résultats envoyés au callback.
{"limit":10,"id":40}limit est plafonné à 100. Pour la page suivante, prenez le plus petit id reçu, soustrayez 1 et envoyez cette valeur dans le prochain DATA.
RÉFÉRENCE API
Tous les endpoints
Chaque opération utilise la même URL et la méthode GET. Ouvrez une fiche pour voir les en-têtes, DATA et le résultat attendu.
SDK
Exemples prêts à adapter
const CAMERPAY_URL = 'https://api.camerpay.net/';
async function camerpayRequest({ service, action, token, data }) {
const headers = {
id: crypto.randomUUID(),
langue: 'FR',
application: 'API_PAY',
service,
action
};
if (token) headers.token = token;
if (data !== undefined) headers.DATA = JSON.stringify(data);
const response = await fetch(CAMERPAY_URL, {
method: 'GET',
headers
});
const result = await response.json();
if (!response.ok || result.etat === false) {
throw new Error(result.message || `Erreur HTTP ${response.status}`);
}
return { httpStatus: response.status, ...result };
}
const deposit = await camerpayRequest({
service: 'transaction',
action: 'depot',
token: process.env.CAMERPAY_TOKEN,
data: { numeroClient: '6XXXXXXXX', montant: 5000 }
});
console.log(deposit.data.replyTo);<?php
function camerpayRequest(string $service, string $action, ?string $token = null, ?array $data = null): array {
$headers = [
'id: ' . bin2hex(random_bytes(16)),
'langue: FR',
'application: API_PAY',
'service: ' . $service,
'action: ' . $action,
'Accept: application/json'
];
if ($token !== null) $headers[] = 'token: ' . $token;
if ($data !== null) $headers[] = 'DATA: ' . json_encode($data);
$curl = curl_init('https://api.camerpay.net/');
curl_setopt_array($curl, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => $headers,
CURLOPT_TIMEOUT => 30
]);
$body = curl_exec($curl);
$status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
if ($body === false) throw new RuntimeException(curl_error($curl));
curl_close($curl);
$result = json_decode($body, true, 512, JSON_THROW_ON_ERROR);
if ($status >= 400 || ($result['etat'] ?? false) === false) {
throw new RuntimeException($result['message'] ?? "Erreur HTTP $status");
}
return ['httpStatus' => $status, 'body' => $result];
}
$deposit = camerpayRequest(
'transaction',
'depot',
getenv('CAMERPAY_TOKEN'),
['numeroClient' => '6XXXXXXXX', 'montant' => 5000]
);import os
import uuid
import json
import requests
CAMERPAY_URL = "https://api.camerpay.net/"
def camerpay_request(service, action, token=None, data=None):
headers = {
"id": str(uuid.uuid4()),
"langue": "FR",
"application": "API_PAY",
"service": service,
"action": action,
"Accept": "application/json",
}
if token:
headers["token"] = token
if data is not None:
headers["DATA"] = json.dumps(data, separators=(",", ":"))
response = requests.get(CAMERPAY_URL, headers=headers, timeout=30)
result = response.json()
if not response.ok or result.get("etat") is False:
raise RuntimeError(result.get("message", f"Erreur HTTP {response.status_code}"))
return response.status_code, result
status, deposit = camerpay_request(
"transaction",
"depot",
token=os.environ["CAMERPAY_TOKEN"],
data={"numeroClient": "6XXXXXXXX", "montant": 5000},
)Ne placez jamais CAMERPAY_TOKEN dans votre frontend, votre application mobile ou un dépôt de code public.
DIAGNOSTIC
Codes HTTP et réactions
| HTTP | Signification | Réaction conseillée |
|---|---|---|
| 200 | Opération synchrone réussie. | Lire etat, message et data. |
| 202 | Demande asynchrone acceptée. | Enregistrer replyTo et attendre le callback. |
| 400 | En-tête, DATA, langue ou action invalide. | Corriger la requête. Ne pas la rejouer à l’identique. |
| 401 | Token, session ou droit invalide. | Recréer une session avec authentification/token. |
| 404 | Identifiants de connexion incorrects. | Vérifier le numéro et le mot de passe. |
| 500 | Erreur interne CamerPay. | Journaliser et réessayer prudemment. |
| 502 | Échec intermédiaire. | Lire le message et contacter le support si nécessaire. |
MISE EN PRODUCTION
Sécurité et checklist
Backend uniquement
Le token et le mot de passe ne doivent jamais être envoyés au navigateur ou à l’application mobile.
Secrets protégés
Utilisez un coffre de secrets ou des variables d’environnement. Masquez les tokens dans les journaux.
Callback robuste
HTTPS obligatoire, traitement idempotent et mécanismes d’authentification convenus avec CamerPay.
Réconciliation
Conservez id, replyTo, statuts et réponses brutes, puis rapprochez régulièrement les rapports.