# Gestion des erreurs
Source: https://docs.lomi.africa/build/reliability/error-handling

Lors de l’intégration avec lomi., traitez les erreurs API pour que vos clients voient un résultat clair et que vos journaux restent utiles.

***

title: 'Gestion des erreurs'
description: "Lors de l’intégration avec lomi., traitez les erreurs API pour que vos clients voient un résultat clair et que vos journaux restent utiles."
----------------------------------------------------------------------------------------------------------------------------------------------------------

Cette page explique comment traiter les erreurs API dans votre application. L’enveloppe, les codes HTTP et la liste stable de `error.code` sont sur [Erreurs](/api/errors).

lomi. utilise les codes HTTP habituels. Branchez-vous sur `error.code`, journalisez `error.message`, et gardez `request_id` pour le support.

## Gestion des types d’erreurs courants

Le SDK TypeScript lève des sous-classes de `LomiError` (`LomiValidationError`, `LomiAuthError`, `LomiNotFoundError`, `LomiRateLimitError`). Il n’existe pas de classe `LomiApiError`.

### Erreurs de validation (HTTP 400)

Elles surviennent lorsque les données de la requête sont invalides ou que des champs obligatoires manquent.

```typescript filename="Gestion des erreurs de validation"
import { LomiSDK, LomiValidationError, LomiError } from '@lomi./sdk';

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

try {
  await lomi.checkoutSessions.create({
    amount: -100,
    currency_code: 'INVALID',
  });
} catch (error) {
  if (error instanceof LomiValidationError) {
    console.error('Validation failed:', error.message, error.details);
  } else if (error instanceof LomiError) {
    console.error('API error:', error.statusCode, error.message);
  }
}
```

### Erreurs d’authentification (HTTP 401)

Elles surviennent lorsque la clé secrète est absente, invalide ou n’a pas les autorisations nécessaires.

```typescript filename="Gestion des erreurs d’authentification"
import { LomiSDK, LomiAuthError } from '@lomi./sdk';

const lomi = new LomiSDK({ apiKey: 'invalid-key' });

try {
  await lomi.providers.list();
} catch (error) {
  if (error instanceof LomiAuthError) {
    console.error('Authentication failed:', error.message, error.requestId);
  }
}
```

### Erreurs de limite de débit (HTTP 429)

Elles surviennent lorsque vous dépassez le nombre de requêtes autorisées. Défaut : 5000 requêtes par 15 minutes ; écritures qui bougent de l’argent : 120 par minute. Voir [Erreurs](/api/errors#rate-limits).

```typescript filename="Gestion des erreurs de limite de débit"
import { LomiSDK, LomiRateLimitError } from '@lomi./sdk';

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

try {
  await lomi.providers.list();
} catch (error) {
  if (error instanceof LomiRateLimitError) {
    const details = error.body?.error?.details;
    const retryAfterSeconds =
      details &&
      typeof details === 'object' &&
      !Array.isArray(details) &&
      typeof details.retry_after_seconds === 'number'
        ? details.retry_after_seconds
        : 60;
    console.warn('Rate limit exceeded. Retry after', retryAfterSeconds, 's');
  }
}
```

### Erreurs serveur (HTTP 5xx)

Elles indiquent un problème côté lomi. Elles doivent rester rares. Réessayez après un délai. Un `503` peut aussi signifier un rail muté comme `POST /charge/switch`.

## Bonnes pratiques

1. **Dégradation gracieuse :** message utilisateur clair, pas le corps API brut. Journalisez `request_id` côté serveur.
2. **Nouvelles tentatives avec recul exponentiel et jitter** pour les erreurs réseau, `429` et `5xx`. Ne réessayez pas les autres `4xx` tant que la requête n’est pas corrigée. Associez les retries aux [clés d’idempotence](/build/reliability/idempotency-keys) sur les écritures qui bougent de l’argent.
3. **Surveillance :** suivez les taux d’erreur en production et alertez sur les pics.

```typescript filename="Nouvelles tentatives avec recul exponentiel"
import { LomiError } from '@lomi./sdk';

async function withRetry<T>(
  asyncFn: () => Promise<T>,
  maxRetries = 3,
  initialDelayMs = 1000,
): Promise<T> {
  let attempts = 0;
  while (true) {
    try {
      return await asyncFn();
    } catch (error) {
      attempts++;
      const isRetryable =
        error instanceof LomiError &&
        (error.statusCode === 429 || (error.statusCode ?? 0) >= 500);

      if (!isRetryable || attempts >= maxRetries) {
        throw error;
      }

      const delay = initialDelayMs * Math.pow(2, attempts - 1);
      const jitter = delay * 0.2 * Math.random();
      const waitTime = Math.max(100, delay + jitter);

      await new Promise((resolve) => setTimeout(resolve, waitTime));
    }
  }
}
```

<DocsNextSteps>
  <DocsNextStep href="/build/reliability/idempotency-keys" hint="Réessais sûrs">
    Clés d’idempotence
  </DocsNextStep>

  <DocsNextStep href="/build/reliability/security-best-practices" hint="Secrets et corps brut">
    Bonnes pratiques de sécurité
  </DocsNextStep>

  <DocsNextStep href="/api/errors" hint="Codes et formes d’erreur">
    Référence des erreurs
  </DocsNextStep>
</DocsNextSteps>