curl -X POST https://admin.fide-pay.com/api/checkout-sessions \
  -H "Content-Type: application/json" \
  -d '{
    "publishable_key": "votre_cle_publique",
    "amount": 25,
    "currency": "EUR",
    "description": "Commande #001",
    "return_url": "https://shop.tld/merci",
    "cancel_url": "https://shop.tld/panier",
    "customer_email": "client@example.com",
    "allowed_domains": ["https://shop.tld"]
  }'

const response = await fetch(
  "https://admin.fide-pay.com/api/checkout-sessions",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      publishable_key: "votre_cle_publique",
      amount: 25,
      currency: "EUR",
      description: "Commande #001",
      return_url: "https://shop.tld/merci",
      cancel_url: "https://shop.tld/panier",
      customer_email: "client@example.com",
      allowed_domains: ["https://shop.tld"]
    })
  }
);

const { data: session } = await response.json();
window.location.assign(session.checkout_url);

{
  "status": "success",
  "data": {
    "id": "jeton_public",
    "public_token": "jeton_public",
    "checkout_url": "https://admin.fide-pay.com/checkout/jeton_public",
    "amount": "25.00000000",
    "currency": "EUR",
    "status": "pending",
    "mode": "sandbox",
    "expires_at": "2026-07-28T14:30:00Z"
  }
}

curl -X POST https://admin.fide-pay.com/api/merchant/access-token \
  -H "Content-Type: application/json" \
  -d '{"public_key":"pk_xxx"}'

const res = await fetch("https://admin.fide-pay.com/api/merchant/access-token", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ public_key: "pk_xxx" })
});

const { token } = await res.json();

$ch = curl_init("https://admin.fide-pay.com/api/merchant/access-token");
curl_setopt_array($ch, [
  CURLOPT_POST => true,
  CURLOPT_HTTPHEADER => ["Content-Type: application/json"],
  CURLOPT_POSTFIELDS => json_encode(["public_key" => "pk_xxx"]),
  CURLOPT_RETURNTRANSFER => true,
]);

$token = json_decode(curl_exec($ch))->token;

import requests

r = requests.post(
  "https://admin.fide-pay.com/api/merchant/access-token",
  json={"public_key": "pk_xxx"},
)

token = r.json()["token"]

var client = HttpClient.newHttpClient();
var req = HttpRequest.newBuilder()
  .uri(URI.create("https://admin.fide-pay.com/api/merchant/access-token"))
  .header("Content-Type", "application/json")
  .POST(HttpRequest.BodyPublishers.ofString("{\"public_key\":\"pk_xxx\"}"))
  .build();

var res = client.send(req, HttpResponse.BodyHandlers.ofString());

payload, _ := json.Marshal(map[string]string{
  "public_key": "pk_xxx",
})

req, _ := http.NewRequest(
  "POST",
  "https://admin.fide-pay.com/api/merchant/access-token",
  bytes.NewBuffer(payload),
)
req.Header.Set("Content-Type", "application/json")

res, _ := http.DefaultClient.Do(req)

using System.Net.Http.Json;

var http = new HttpClient();
var response = await http.PostAsJsonAsync(
  "https://admin.fide-pay.com/api/merchant/access-token",
  new { public_key = "pk_xxx" }
);

var body = await response.Content.ReadFromJsonAsync<TokenResponse>();
var token = body?.Token;

require "net/http"
require "json"

uri = URI("https://admin.fide-pay.com/api/merchant/access-token")
res = Net::HTTP.post(
  uri,
  { public_key: "pk_xxx" }.to_json,
  "Content-Type" => "application/json"
)

token = JSON.parse(res.body)["token"]

curl -X POST https://admin.fide-pay.com/api/merchant/make-payment \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 5000,
    "currency": "XOF",
    "country": "BJ",
    "transaction_id": "BJXOF260001",
    "description": "Ticket Benin",
    "ipn_url": "https://shop.tld/webhook",
    "callback_url": "https://shop.tld/ok",
    "customer_name": "Alice",
    "customer_email": "alice@exemple.com"
  }'

const pay = await fetch("https://admin.fide-pay.com/api/merchant/make-payment", {
  method: "POST",
  headers: {
    Authorization: "Bearer " + token,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    amount: 5000,
    currency: "XOF",
    country: "BJ",
    transaction_id: "BJXOF260001",
    description: "Ticket Benin",
    ipn_url: "https://shop.tld/webhook",
    callback_url: "https://shop.tld/ok"
  })
});

const { payment_url } = await pay.json();

$ch = curl_init("https://admin.fide-pay.com/api/merchant/make-payment");
curl_setopt_array($ch, [
  CURLOPT_POST => true,
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer " . $token,
    "Content-Type: application/json"
  ],
  CURLOPT_POSTFIELDS => json_encode([
    "amount" => 5000,
    "currency" => "XOF",
    "country" => "BJ",
    "transaction_id" => "BJXOF260001",
    "description" => "Ticket Benin",
    "ipn_url" => "https://shop.tld/webhook",
    "callback_url" => "https://shop.tld/ok"
  ]),
  CURLOPT_RETURNTRANSFER => true,
]);

$paymentUrl = json_decode(curl_exec($ch))->payment_url;

pay = requests.post(
  "https://admin.fide-pay.com/api/merchant/make-payment",
  headers={"Authorization": f"Bearer {token}"},
  json={
    "amount": 5000,
    "currency": "XOF",
    "country": "BJ",
    "transaction_id": "BJXOF260001",
    "description": "Ticket Benin",
    "ipn_url": "https://shop.tld/webhook",
    "callback_url": "https://shop.tld/ok",
  },
)

payment_url = pay.json()["payment_url"]

String body = """
{
  "amount": 5000,
  "currency": "XOF",
  "country": "BJ",
  "transaction_id": "BJXOF260001",
  "description": "Ticket Benin",
  "ipn_url": "https://shop.tld/webhook",
  "callback_url": "https://shop.tld/ok"
}
""";

var req = HttpRequest.newBuilder()
  .uri(URI.create("https://admin.fide-pay.com/api/merchant/make-payment"))
  .header("Authorization", "Bearer " + token)
  .header("Content-Type", "application/json")
  .POST(HttpRequest.BodyPublishers.ofString(body))
  .build();

payload := map[string]any{
  "amount": 5000,
  "currency": "XOF",
  "country": "BJ",
  "transaction_id": "BJXOF260001",
  "description": "Ticket Benin",
  "ipn_url": "https://shop.tld/webhook",
  "callback_url": "https://shop.tld/ok",
}

body, _ := json.Marshal(payload)
req, _ := http.NewRequest(
  "POST",
  "https://admin.fide-pay.com/api/merchant/make-payment",
  bytes.NewBuffer(body),
)
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")

res, _ := http.DefaultClient.Do(req)

using System.Net.Http.Headers;
using System.Net.Http.Json;

var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
  new AuthenticationHeaderValue("Bearer", token);

var response = await http.PostAsJsonAsync(
  "https://admin.fide-pay.com/api/merchant/make-payment",
  new {
    amount = 5000,
    currency = "XOF",
    country = "BJ",
    transaction_id = "BJXOF260001",
    description = "Ticket Benin",
    ipn_url = "https://shop.tld/webhook",
    callback_url = "https://shop.tld/ok"
  }
);

require "net/http"
require "json"

uri = URI("https://admin.fide-pay.com/api/merchant/make-payment")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{token}"
req["Content-Type"] = "application/json"
req.body = {
  amount: 5000,
  currency: "XOF",
  country: "BJ",
  transaction_id: "BJXOF260001",
  description: "Ticket Benin",
  ipn_url: "https://shop.tld/webhook",
  callback_url: "https://shop.tld/ok"
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }

status=success
signature=<hex hmac-sha256>
data[transaction_id]=ORD-001
data[total_amount]=25.50
data[currency]=EUR
data[customer_email]=alice@exemple.com

import crypto from "crypto";

const expected = crypto
  .createHmac("sha256", secretKey)
  .update(data.transaction_id + data.total_amount)
  .digest("hex");

if (crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature))) {
  // créditez la commande, répondez 200
}

$expected = hash_hmac(
  "sha256",
  $_POST["data"]["transaction_id"] . $_POST["data"]["total_amount"],
  $secretKey
);

if (!hash_equals($expected, $_POST["signature"])) {
  http_response_code(401);
  exit;
}

import hmac, hashlib

expected = hmac.new(
  secret_key.encode(),
  (data["transaction_id"] + data["total_amount"]).encode(),
  hashlib.sha256
).hexdigest()

if hmac.compare_digest(expected, signature):
  pass  # créditez la commande, répondez 200

Mac mac = Mac.getInstance("HmacSHA256");
mac.init(new SecretKeySpec(secretKey.getBytes(), "HmacSHA256"));

byte[] raw = mac.doFinal((transactionId + totalAmount).getBytes());
String expected = HexFormat.of().formatHex(raw);

if (!MessageDigest.isEqual(expected.getBytes(), signature.getBytes())) {
  // return 401
}

mac := hmac.New(sha256.New, []byte(secretKey))
mac.Write([]byte(transactionID + totalAmount))
expected := hex.EncodeToString(mac.Sum(nil))

if !hmac.Equal([]byte(expected), []byte(signature)) {
  // return HTTP 401
}

using System.Security.Cryptography;
using System.Text;

var message = transactionId + totalAmount;
using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var expected = Convert.ToHexString(
  hmac.ComputeHash(Encoding.UTF8.GetBytes(message))
).ToLowerInvariant();

if (!CryptographicOperations.FixedTimeEquals(
  Encoding.UTF8.GetBytes(expected),
  Encoding.UTF8.GetBytes(signature)
)) {
  // return HTTP 401
}

require "openssl"

message = "#{transaction_id}#{total_amount}"
expected = OpenSSL::HMAC.hexdigest("SHA256", secret_key, message)

unless Rack::Utils.secure_compare(expected, signature)
  halt 401
end

curl "https://admin.fide-pay.com/api/merchant/payment-methods?country=BJ" \
  -H "Authorization: Bearer VOTRE_ACCESS_TOKEN" \
  -H "Accept: application/json"

$payload = json_decode(file_get_contents('php://input'), true);
$secret  = $payload['environment'] === 'sandbox'
    ? getenv('FIDEPAY_SECRET_SANDBOX')   // sandbox_…
    : getenv('FIDEPAY_SECRET_LIVE');

$expected = hash_hmac(
    'sha256',
    $payload['data']['transaction_id'] . $payload['data']['total_amount'],
    $secret
);

if (! hash_equals($expected, $payload['signature'])) {
    http_response_code(401);
    exit;                 // signature invalide : ignorer la notification
}
// Traiter l'événement, puis répondre 200.

const crypto = require("crypto");

app.post("/fidepay/webhook", (req, res) => {
  const payload = req.body;
  const secret = payload.environment === "sandbox"
    ? process.env.FIDEPAY_SECRET_SANDBOX   // sandbox_…
    : process.env.FIDEPAY_SECRET_LIVE;

  const expected = crypto.createHmac("sha256", secret)
    .update(payload.data.transaction_id + payload.data.total_amount)
    .digest("hex");

  const valid = crypto.timingSafeEqual(
    Buffer.from(expected), Buffer.from(payload.signature));
  if (!valid) return res.status(401).end();

  // Traiter l'événement, puis répondre 200.
  res.json({ received: true });
});

import hmac, hashlib, os

@app.post("/fidepay/webhook")
def fidepay_webhook():
    payload = request.get_json(force=True)
    secret = (os.environ["FIDEPAY_SECRET_SANDBOX"]   # sandbox_…
              if payload["environment"] == "sandbox"
              else os.environ["FIDEPAY_SECRET_LIVE"])

    expected = hmac.new(
        secret.encode(),
        (payload["data"]["transaction_id"] + payload["data"]["total_amount"]).encode(),
        hashlib.sha256,
    ).hexdigest()

    if not hmac.compare_digest(expected, payload["signature"]):
        return "", 401

    # Traiter l'événement, puis répondre 200.
    return {"received": True}

curl -X POST https://admin.fide-pay.com/api/billing/subscribe \
  -H "Content-Type: application/json" \
  -d '{
    "plan_token": "plan_XXXXXXXXXXXXXXXXXXXXXXXX",
    "customer_name": "Awa Diop",
    "customer_email": "awa@example.com",
    "method": "mobile_money"
  }'

const response = await fetch(
  "https://admin.fide-pay.com/api/billing/subscribe",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      plan_token: "plan_XXXXXXXXXXXXXXXXXXXXXXXX",
      customer_name: "Awa Diop",
      customer_email: "awa@example.com",
      method: "mobile_money"
    })
  }
);

const { data } = await response.json();
if (data.subscription.payment_url) {
  // Premier cycle à régler : redirigez vers le lien de paiement.
  window.location.assign(data.subscription.payment_url);
}

<?php
// Laravel / PHP natif — aucune dépendance requise.
$payload = [
    'plan_token' => 'plan_XXXXXXXXXXXXXXXXXXXXXXXX',
    'customer_name' => 'Awa Diop',
    'customer_email' => 'awa@example.com',
    'method' => 'mobile_money',
];

$ch = curl_init('https://admin.fide-pay.com/api/billing/subscribe');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
    CURLOPT_POSTFIELDS => json_encode($payload),
]);

$response = json_decode(curl_exec($ch), true);
curl_close($ch);

$subscription = $response['data']['subscription'];
if (! empty($subscription['payment_url'])) {
    // Premier cycle à régler : redirigez vers le lien de paiement.
    header('Location: ' . $subscription['payment_url']);
    exit;
}

# Django / Flask / FastAPI — avec la librairie requests.
import requests

response = requests.post(
    "https://admin.fide-pay.com/api/billing/subscribe",
    json={
        "plan_token": "plan_XXXXXXXXXXXXXXXXXXXXXXXX",
        "customer_name": "Awa Diop",
        "customer_email": "awa@example.com",
        "method": "mobile_money",
    },
    timeout=15,
)
response.raise_for_status()

subscription = response.json()["data"]["subscription"]
if subscription.get("payment_url"):
    # Premier cycle à régler : redirigez vers le lien de paiement.
    redirect_url = subscription["payment_url"]

// Flutter / Dart — package http.
import 'dart:convert';
import 'package:http/http.dart' as http;

final response = await http.post(
  Uri.parse('https://admin.fide-pay.com/api/billing/subscribe'),
  headers: {'Content-Type': 'application/json'},
  body: jsonEncode({
    'plan_token': 'plan_XXXXXXXXXXXXXXXXXXXXXXXX',
    'customer_name': 'Awa Diop',
    'customer_email': 'awa@example.com',
    'method': 'mobile_money',
  }),
);

final subscription =
    jsonDecode(response.body)['data']['subscription'];
if (subscription['payment_url'] != null) {
  // Premier cycle à régler : ouvrez le lien de paiement
  // (url_launcher ou WebView selon votre app).
  final paymentUrl = subscription['payment_url'];
}

{
  "status": "success",
  "data": {
    "subscription": {
      "token": "sub_XXXXXXXXXXXXXXXXXXXXXXXX",
      "status": "pending_payment",
      "current_period_end": null,
      "payment_url": "https://admin.fide-pay.com/pay/TRX..."
    }
  }
}

import Fidepay from "./fidepay.js";

const fidepay = new Fidepay("votre_cle_publique");

const session = await fidepay.create({
  amount: 25,
  currency: "EUR",
  description: "Commande #001",
  allowedDomains: [window.location.origin],
  returnUrl: "https://shop.tld/merci"
});

fidepay.checkout({
  sessionToken: session.sessionToken,
  mode: "overlay",
  onSuccess: (payment) => console.log("Paiement confirmé", payment),
  onCancel: () => console.log("Paiement annulé"),
  onError: (error) => console.error(error)
});