Configurez votre intégration lomi. et commencez à accepter les paiements en quelques minutes.

Premiers pas

Mettez votre intégration lomi. en route en quelques minutes. Que vous soyez une startup lançant votre MVP ou une entreprise établie, nous avons rationalisé l’onboarding pour que vous acceptiez les paiements très rapidement.

Paliers d’activité

lomi. propose deux parcours de vérification pour accompagner les entreprises à différents stades :

Starter

Adapté aux startups, aux profils indépendants et aux MVP en phase de test du marché.

Exigences : pièce d’identité officielle valide (passeport, carte d’identité nationale ou permis de conduire).
Plafond de transactions : 650 000 F CFA (~1 000 USD).
Délai d’approbation : moins d’une heure.

Démarrez en « Starter » pour valider votre produit, puis passez à « Business » lorsque vous êtes prêts à passer à l’échelle.

Business

Pour les entreprises établies prêtes à traiter des transactions sans limitation de volume.

Exigences : immatriculation de l’entreprise et justificatif de domicile.
Plafond de transactions : illimité.
Délai d’approbation : 24 heures.

Démarrage rapide

Créer votre compte

Inscrivez-vous sur dashboard.lomi.africa et suivez le parcours d’onboarding :

Créez un compte par e-mail ou via Google, Github, LinkedIn ou Microsoft.
Indiquez vos informations personnelles (nom, téléphone, pays, adresse, cas d’usage).
Téléversez une pièce d’identité (pour Starter) ou l’ensemble des documents d’entreprise.

Nous demandons une pièce d’identité pour vérifier votre identité et parce que nous devons savoir qui vous êtes pour vous permettre d’accepter des paiements. Cette étape est obligatoire pour tous les utilisateurs ; ces informations peuvent être communiquées à certains de nos partenaires, notamment PSP, banques et autorités de régulation. Pour en savoir plus, consultez notre Politique de confidentialité. Nous ne vendrons jamais vos données à des tiers ni ne les utiliserons à d’autres fins que la fourniture de nos services.

Une fois le dossier envoyé, les comptes Starter sont approuvés immédiatement. Les comptes Business sont examinés sous 24 heures.

Obtenir vos jetons d’accès

Allez dans Settings → Access tokens de votre tableau de bord pour trouver vos clés uniques.

lomi. fournit deux types de clés pour chaque environnement :

Type de clé	Préfixe	Usage
Clé publiable	`lomi_pk_test_...` / `lomi_pk_live_...`	Côté client. Opérations limitées.
Clé secrète	`lomi_sk_test_...` / `lomi_sk_live_...`	Uniquement côté serveur. Accès API complet.

N’exposez jamais les clés secrètes dans le code client. Utilisez les clés publiables pour les applications web front-end et mobiles.

Installer le SDK

Choisissez votre langage et installez le SDK lomi. :

# Using npm
npm install @lomi./sdk

# Using pnpm

pnpm add @lomi./sdk

# Using yarn

yarn add @lomi./sdk

pip install lomi-sdk

go get github.com/lomiafrica/lomi-go-sdk

Ajoutez dans votre composer.json :

{
  "repositories": [
    {
      "type": "vcs",
      "url": "https://github.com/lomiafrica/lomi./"
    }
  ],
  "require": {
    "lomi/lomi-sdk": "dev-main#apps/sdks/php"
  }
}

Puis exécutez :

composer install

# Using npm
npm install @lomi./sdk-next

# Using pnpm

pnpm add @lomi./sdk-next

Définir vos variables d’environnement

Configurez vos identifiants API :

export LOMI_SECRET_KEY=lomi_sk_live_xxxxxxxxxxxxxxxxxxxxxx
export LOMI_PUBLISHABLE_KEY=lomi_pk_live_xxxxxxxxxxxxxxxxxxxxxx

Effectuer votre premier appel API

Initialisez le SDK et vérifiez votre connexion :

import { LomiSDK } from '@lomi./sdk';

// Initialize the SDK
const lomi = new LomiSDK({
  apiKey: process.env.LOMI_SECRET_KEY!,
  environment: 'live', // Use 'live' for production
});

async function listCustomers() {
  try {
    const customers = await lomi.customers.list();
    console.log('Customers:', customers);
  } catch (error) {
    console.error('Error:', error);
  }
}

listCustomers();

import os
from lomi import LomiClient, LomiError

# Initialize the SDK
client = LomiClient(
    api_key=os.environ["LOMI_SECRET_KEY"],
    environment="live"
)

try:
    customers = client.customers.list()
    print("Customers:", customers)
except LomiError as e:
    print(f"Error: {e}")

package main

import (
    "context"
    "fmt"
    "os"
    
    lomi "github.com/lomiafrica/lomi-go-sdk"
)

func main() {
configuration := lomi.NewConfiguration()
client := lomi.NewAPIClient(configuration)

    auth := context.WithValue(
        context.Background(),
        lomi.ContextAPIKeys,
        map[string]lomi.APIKey{
            "ApiKeyAuth": {Key: os.Getenv("LOMI_SECRET_KEY")},
        },
    )

    customers, _, err := client.CustomersAPI.ListCustomers(auth).Execute()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Customers: %v\n", customers)

}

<?php
require_once 'vendor/autoload.php';

use Lomi\Configuration;
use Lomi\Api\CustomersApi;

$config = Configuration::getDefaultConfiguration()
    ->setApiKey('X-API-KEY', getenv('LOMI_SECRET_KEY'));

$apiInstance = new CustomersApi(null, $config);

try {
    $customers = $apiInstance->listCustomers();
    print_r($customers);
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

// lib/lomi/server.ts (Server-side)
import { LomiSDK } from '@lomi./sdk';

export const lomi = new LomiSDK({
  apiKey: process.env.LOMI_SECRET_KEY!,
  environment: 'live',
});

// app/customers/page.tsx (Server Component)
import { lomi } from '@/lib/lomi/server';

export default async function CustomersPage() {
  const customers = await lomi.customers.list();
  
  return (
    <ul>
      {customers.data?.map((customer) => (
        <li key={customer.id}>{customer.name}</li>
      ))}
    </ul>
  );
}

Avec curl :

curl -X GET "https://sandbox.api.lomi.africa/customers" \
  -H "X-API-KEY: ${LOMI_SECRET_KEY}"

Créer une session de paiement

Créez une page de paiement hébergée pour encaisser des paiements :

import { LomiSDK } from '@lomi./sdk';

const lomi = new LomiSDK({
apiKey: process.env.LOMI_SECRET_KEY!,
environment: 'live',
});

async function createCheckout() {
  const session = await lomi.checkoutSessions.create({
    amount: 5000, // 5,000 F CFA
    currency_code: 'XOF',
    success_url: 'https://yoursite.com/success',
    cancel_url: 'https://yoursite.com/cancel',
    customer_email: 'customer@example.com',
    title: 'Premium Coffee Mug',
  });

console.log('Redirect customer to:', session.checkout_url);
}

createCheckout();

import os
from lomi import LomiClient

client = LomiClient(
    api_key=os.environ["LOMI_SECRET_KEY"],
    environment="live"
)

session = client.checkout_sessions.create({
    "amount": 5000,  # 5,000 F CFA
    "currency_code": "XOF",
    "success_url": "https://yoursite.com/success",
    "cancel_url": "https://yoursite.com/cancel",
    "customer_email": "customer@example.com",
    "title": "Premium Coffee Mug"
})

print(f"Redirect customer to: {session['checkout_url']}")

sessionData := lomi.CheckoutSessionsCreate{
    Amount:        lomi.PtrInt32(5000),
    CurrencyCode:  lomi.PtrString("XOF"),
    SuccessUrl:    lomi.PtrString("https://yoursite.com/success"),
    CancelUrl:     lomi.PtrString("https://yoursite.com/cancel"),
    CustomerEmail: lomi.PtrString("customer@example.com"),
    Title:         lomi.PtrString("Premium Coffee Mug"),
}

session, \_, err := client.CheckoutSessionsAPI.CreateCheckoutSession(auth).
CheckoutSessionsCreate(sessionData).
Execute()

if err != nil {
fmt.Printf("Error: %v\n", err)
return
}

fmt.Printf("Redirect customer to: %s\n", \*session.CheckoutUrl)

use Lomi\Api\CheckoutSessionsApi;
use Lomi\Model\CheckoutSessionsCreate;

$checkoutApi = new CheckoutSessionsApi(null, $config);

$session = $checkoutApi->createCheckoutSession(
    new CheckoutSessionsCreate([
        'amount' => 5000, // 5,000 F CFA
        'currency_code' => 'XOF',
        'success_url' => 'https://yoursite.com/success',
        'cancel_url' => 'https://yoursite.com/cancel',
        'customer_email' => 'customer@example.com',
        'title' => 'Premium Coffee Mug'
    ])
);

header('Location: ' . $session->getCheckoutUrl());
exit;

Configurer les webhooks

Les webhooks informent votre serveur d’événements comme les paiements réussis :

import express from 'express';
import crypto from 'crypto';

const app = express();
app.use(express.json({
verify: (req: any, \_res, buf) => {
req.rawBody = buf;
},
}));

app.post('/webhook', (req: any, res) => {
const signature = req.headers['x-lomi-signature'] as string;
const secret = process.env.LOMI_WEBHOOK_SECRET!;

// Verify signature
const expectedSignature = crypto
.createHmac('sha256', secret)
.update(req.rawBody)
.digest('hex');

if (signature !== expectedSignature) {
return res.status(400).send('Invalid signature');
}

const event = req.body;

switch (event.type) {
case 'PAYMENT_SUCCEEDED':
console.log('Payment succeeded:', event.data);
// Fulfill the order
break;

}

res.status(200).json({ received: true });
});

app.listen(3000);

import hmac
import hashlib
import os
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook():
    signature = request.headers.get('x-lomi-signature')
    secret = os.environ['LOMI_WEBHOOK_SECRET'].encode()

    expected = hmac.new(secret, request.data, hashlib.sha256).hexdigest()

    if not hmac.compare_digest(signature, expected):
        return jsonify({'error': 'Invalid signature'}), 400

    event = request.json

    if event['type'] == 'PAYMENT_SUCCEEDED':
        print('Payment succeeded:', event['data'])
        # Fulfill the order

    return jsonify({'received': True})

if __name__ == '__main__':
    app.run(port=3000)

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    signature := r.Header.Get("x-lomi-signature")
    secret := os.Getenv("LOMI_WEBHOOK_SECRET")
    
    body, _ := io.ReadAll(r.Body)
    
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(body)
    expected := hex.EncodeToString(mac.Sum(nil))
    
    if !hmac.Equal([]byte(signature), []byte(expected)) {
        http.Error(w, "Invalid signature", http.StatusBadRequest)
        return
    }
    
    var event map[string]interface{}
    json.Unmarshal(body, &event)
    
    if event["type"] == "PAYMENT_SUCCEEDED" {
        log.Printf("Payment succeeded: %v", event["data"])
        // Fulfill the order
    }
    
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]bool{"received": true})
}

<?php
$signature = $_SERVER['HTTP_X_LOMI_SIGNATURE'] ?? '';
$secret = getenv('LOMI_WEBHOOK_SECRET');
$payload = file_get_contents('php://input');

$expected = hash_hmac('sha256', $payload, $secret);

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

$event = json_decode($payload, true);

if ($event['type'] === 'PAYMENT_SUCCEEDED') {
    error_log('Payment succeeded: ' . json_encode($event['data']));
// Fulfill the order
}

http_response_code(200);
echo json_encode(['received' => true]);

Pensez à :

définir la variable d’environnement LOMI_WEBHOOK_SECRET ;
utiliser ngrok pour exposer votre serveur local pendant le développement ;
enregistrer l’URL de votre webhook dans le tableau de bord sous Webhooks pour obtenir votre secret et être notifié lorsqu’un paiement réussit.

Étapes suivantes

Gérer les variables d’environnement — clés secrètes et clés publiables
Configurer les webhooks — traiter les événements de paiement
Traiter les transactions — consulter et gérer les paiements

Assistance

E-mail : hello@lomi.africa
Statut de l’API : status.lomi.africa
Planifier un appel : Réserver une démo

Premiers pas

Sur cette page