Comment intégrer les paiements Orange Money ou MTN Momo au Cameroun dans son application avec Python ?

Si tu recherches un moyen d’intégrer le paiement par mobile money dans ton application Python, cet article est fait pour toi. Il est très simple et met en exergue l’API de Notchpay.

Notchpay est une application concurrente de Stripe : elle t’offre un moyen d’intégrer des moyens de paiement dans ton application et supporte les paiements par carte et par mobile money

Pour l’intégrer c’est simple : 

Il faut d’abord créer son compte sur Notchpay. À la création, ton compte te donne accès à une sandbox qui permet de tester l’API. Au niveau des paramètres (Settings > Developer), tu pourras trouver ta clé API (PUBLIC_KEY) que tu vas utiliser pour authentifier dans ton application.

Initiation du paiement

La documentation présente déjà toutes les API que tu peux utiliser, notamment dans la section API reference.

Dans notre cas, nous allons utiliser Flask pour les controlleurs et la librairie Requests pour faire des requêtes vers Notchpay

Tu vas initialiser le paiement

def initialize_payment(
    email, currency, amount, phone, reference, description, callback
):
    headers = {"Authorization": PUBLIC_KEY, "Accept": "application/json"}
    url = "https://api.notchpay.co/payments/initialize"
    data = {
        "email": email,
        "currency": currency,
        "amount": amount,
        "phone": phone,
        "reference": reference,
        "description": description,
        "callback": callback,
    }

    response = requests.post(url, headers=headers, data=data)

    if response.ok:
        json_response = response.json()
        return json_response
    else:
        return {"status_code": response.status_code, "msg": response.text}

Dans cette fonction,

1. on définit en argument les données nécessaires pour le paiement, ici dans la variable data,
2. puis le header à travers lequel on exécute notre requête. Ce header contient l'API Key
3. avant de retourner une réponse de type JSON.

Pour avoir plus d’info sur ce endpoint d'initiation de paiement et la réponse JSON, rends-toi juste sur la documentation de l’URL /payments/initialize

De plus, il faut noter que le callback sera un contrôleur de ton site qui sera appelé après le paiement. Tu pourras l'utiliser pour implémenter la vérification du paiement. 

• À partir de là, on va créer nos contrôleurs : d’abord une simple page web qui affiche un lien <<Pay Now>>.
• Lorsqu’on clique sur ce lien, le controlleur pay() est appelé et va initier le paiement et rediriger vers Notchpay grâce à cette ligne

return redirect(init_payment.get("authorization_url")) 

• À ce niveau, la page de Notchpay dédiée au paiement va s’afficher
• L’utilisateur pourra alors faire son paiement via carte bancaire ou numéro de téléphone mobile money

HTML_PAGE = """
<h1>Process payment</h1>
<a href="/pay">Pay Now</a>
"""

@app.route("/")
def home():
    return HTML_PAGE

@app.route("/pay")
def pay():
    payment_reference = uuid.uuid1()
    init_payment = initialize_payment(
        email="customersss@email.com",
        currency="XAF",
        amount="1500",
        phone=None,
        reference=payment_reference,
        description=f"Payment description {payment_reference}",
        callback=f"http://localhost:5000/verify", # make sure to have right host
    )
    return redirect(init_payment.get("authorization_url"))

Lorsque le paiement est fait par l’utilisateur, il faut alors le vérifier à travers le callback qui a été passé à la fonction initialize_payment().

Vérification du paiement

def verify_payment(reference):
    url = f"https://api.notchpay.co/payments/{reference}"
    headers = {"Authorization": PUBLIC_KEY}

    response = requests.get(url, headers=headers)

    if response.ok:
        json_response = response.json()
        logger.debug(json_response)
        return json_response
    else:
        return {"status_code": response.status_code, "msg": response.text}

1. Cette fonction prend en paramètre la référence du paiement qui est passée dans le callback via une méthode GET de Notchpay.
2. Nous construisons ensuite le header à travers l’URL /payments/{reference} pour la vérification du paiement
3. et retournons une réponse en JSON

Le callback quant à lui sera le contrôleur verify() qui va extraire la référence et passer cette référence de paiement à la fonction verify_payement()

@app.route("/verify")
def verify():
    reference = request.args.get("reference")
    return verify_payment(reference)

À partir de là, tu peux juste récupérer la réponse JSON pour continuer ton process en fonction de la réponse (échec ou succès du paiement)

Vérification du paiement à travers un webhook

Si tu veux vérifier les paiements en arrière-plan, tu peux mettre en place un webhook dans ton backend comme celui-ci

@app.route("/webhook", methods=["POST"])
def webhook():
    signature = request.headers.get("x-notch-signature")
    hash_value = hashlib.sha256(HASH_KEY).hexdigest()
    if hash_value == signature:
        try:
            json_data = request.get_json()
            logger.info("Webhook data:", json_data)
            return "", 200  # OK
        except Exception as e:
            logger.info("Error parsing JSON:", e)
            abort(400)  # Bad request
    else:
        logger.info("Webhook request could not be verified.")
        abort(403)  # Forbidden

Notchay va alors renvoyer la réponse de chaque paiement à ton webhook et en fonction du résultat, tu pourras continuer ton process, comme valider une commande par exemple.

Si tu es en localhost, tu devras installer Ngrock pour rendre ton URL publique et aller sur l’interface d’administration de Notchpay pour définir ton webhook avec une clé et ton URL

La clé quant à elle sera celle que tu vas utiliser comme HASH_KEY pour authentifier ton serveur afin que Notchpay reconnaisse ta signature.

Voilà, c’est tout pour le moment

Tu peux retrouver le code complet ici sur GitHub 

Si tu as des questions, n’hésite pas à les poser en commentaire

A+