> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bodyguard.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction

> Apprenez à vous authentifier, à gérer les erreurs et à comprendre les limites de débit de l'API Bodyguard Analyze.

L'API Bodyguard Analyze classifie **texte**, **images** et **noms d'utilisateur** pour détecter tout contenu nuisible ou indésirable. Toutes les requêtes sont effectuées en HTTPS vers :

```text theme={null}
https://api.bodyguard.ai
```

`api.bodyguard.ai` est un endpoint global à utiliser par défaut. `api.bodyguard.ai` est situé dans la région de Bruxelles (Belgique).

### Endpoints régionaux

Pour réduire la latence, vous pouvez envoyer vos requêtes directement vers une région spécifique :

| Région  | Localisation                 | URL de base                    |
| ------- | ---------------------------- | ------------------------------ |
| US East | Virginie du Nord, États-Unis | `https://api.us1.bodyguard.ai` |
| US West | Californie, États-Unis       | `https://api.us2.bodyguard.ai` |

<Note>
  Les endpoints régionaux exposent la même API que l'endpoint global — seule l'URL de base change. Votre clé d'API fonctionne dans toutes les régions.
</Note>

## Démarrage rapide

L'exemple suivant analyse un message texte. Remplacez `<your-api-key>` et `<your-channel-id>` par les valeurs fournies par Bodyguard.

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://api.bodyguard.ai/analyze/v1/text \
    -H "Authorization: ApiKey <your-api-key>" \
    -H "Content-Type: application/json" \
    -d '{
      "channelId": "<your-channel-id>",
      "text": "Einstein is an asshole",
      "publishedAt": "2026-04-23T10:30:00.000Z"
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch("https://api.bodyguard.ai/analyze/v1/text", {
    method: "POST",
    headers: {
      Authorization: "ApiKey <your-api-key>",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      channelId: "<your-channel-id>",
      text: "Einstein is an asshole",
      publishedAt: "2026-04-23T10:30:00.000Z",
    }),
  });

  const result = await response.json();
  console.log(result);
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      "https://api.bodyguard.ai/analyze/v1/text",
      headers={
          "Authorization": "ApiKey <your-api-key>",
          "Content-Type": "application/json",
      },
      json={
          "channelId": "<your-channel-id>",
          "text": "Einstein is an asshole",
          "publishedAt": "2026-04-23T10:30:00.000Z",
      },
  )

  print(response.json())
  ```

  ```go Go theme={null}
  package main

  import (
  	"bytes"
  	"encoding/json"
  	"fmt"
  	"io"
  	"net/http"
  )

  func main() {
  	body, _ := json.Marshal(map[string]string{
  		"channelId":   "<your-channel-id>",
  		"text":        "Einstein is an asshole",
  		"publishedAt": "2026-04-23T10:30:00.000Z",
  	})

  	req, _ := http.NewRequest("POST", "https://api.bodyguard.ai/analyze/v1/text", bytes.NewReader(body))
  	req.Header.Set("Authorization", "ApiKey <your-api-key>")
  	req.Header.Set("Content-Type", "application/json")

  	resp, err := http.DefaultClient.Do(req)
  	if err != nil {
  		panic(err)
  	}
  	defer resp.Body.Close()

  	out, _ := io.ReadAll(resp.Body)
  	fmt.Println(string(out))
  }
  ```
</CodeGroup>

Pour interpréter la réponse, consultez la [taxonomie des classifications de texte](/fr/documentation/taxonomy/text-classifications).

## Authentification

Toutes les requêtes doivent inclure un en-tête `Authorization` utilisant le schéma `ApiKey`. Le nom du schéma est sensible à la casse — `ApiKey` doit être écrit exactement comme indiqué.

### En-têtes de requête requis

| En-tête         | Valeur                  |
| --------------- | ----------------------- |
| `Authorization` | `ApiKey <your-api-key>` |
| `Content-Type`  | `application/json`      |

Votre clé API est fournie par Bodyguard. Gardez-la secrète et ne l'exposez jamais côté client.

### Erreurs d'authentification

Tous les échecs d'authentification renvoient une réponse `401 Unauthorized` avec le code `AUTHENTICATION_ERROR` et l'une des raisons suivantes :

| Condition                | `reason`                      |
| ------------------------ | ----------------------------- |
| Clé invalide ou inconnue | `REASON_INVALID_CREDENTIALS`  |
| Clé expirée              | `REASON_EXPIRED_CREDENTIALS`  |
| Clé désactivée           | `REASON_DISABLED_CREDENTIALS` |

La raison est renvoyée dans le champ `details.authenticationError.reason` de l'enveloppe d'erreur. Voir [Erreurs](#erreurs) pour le format complet de la réponse et un exemple concret.

## Versionnement

Les endpoints vivent sous un chemin versionné — par exemple, `/analyze/v1/text`. Les endpoints en `/v1/` sont stables et Bodyguard s'engage sur leur stabilité d'API. Tout changement cassant sera introduit sous un nouveau chemin de version (par exemple `/v2/`), vous permettant de migrer à votre propre rythme.

## Limites de débit

Les limites de débit sont appliquées **par organisation**. Chaque endpoint a son propre quota indépendant. Les quotas sont spécifiques à chaque client et négociés dans le cadre de votre contrat.

Lorsque votre organisation dépasse un quota, l'API renvoie `429 Too Many Requests` avec le code `QUOTA_ERROR`. Le tableau `details.quotaError.violations` de l'enveloppe de réponse identifie le quota spécifique qui a été dépassé.

```json theme={null}
{
  "error": {
    "code": "QUOTA_ERROR",
    "details": {
      "quotaError": {
        "violations": [
          {
            "quotaName": "analyze.message.requests_per_second",
            "quotaValue": 10
          }
        ]
      }
    }
  }
}
```

Besoin d'un ajustement de quota ? [Contactez-nous](https://www.bodyguard.ai/contact-us).

## Erreurs

Toutes les erreurs suivent une enveloppe JSON cohérente :

```json theme={null}
{
  "error": {
    "code": "<error-code>",
    "details": { }
  }
}
```

L'objet `details` contient des informations structurées propres au type d'erreur et possède exactement un champ dont le nom correspond au code d'erreur (par exemple `badRequestError` pour `BAD_REQUEST_ERROR`). Le `Content-Type` des réponses d'erreur est toujours `application/json`.

### Codes d'erreur

| Statut HTTP               | `code`                      | Charge utile `details`                                    | Quand cela se produit                                                                                                               |
| ------------------------- | --------------------------- | --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `400 Bad Request`         | `BAD_REQUEST_ERROR`         | `badRequestError.fieldViolations[]`                       | Un champ obligatoire est manquant ou la valeur d'un champ est invalide. Le tableau `fieldViolations` identifie chaque champ fautif. |
| `401 Unauthorized`        | `AUTHENTICATION_ERROR`      | `authenticationError.reason`                              | La clé API est manquante, invalide, expirée ou désactivée.                                                                          |
| `403 Forbidden`           | `PERMISSION_DENIED_ERROR`   | `permissionDeniedError.permission`, `.resourceIdentifier` | La clé API n'a pas la permission d'effectuer l'action demandée sur la ressource.                                                    |
| `404 Not Found`           | `NOT_FOUND_ERROR`           | `notFoundError.resourceIdentifier`                        | La ressource demandée n'existe pas.                                                                                                 |
| `409 Conflict`            | `CONFLICT_ERROR`            | `conflictError.reason`                                    | La requête entre en conflit avec l'état actuel d'une ressource.                                                                     |
| `412 Precondition Failed` | `PRECONDITION_FAILED_ERROR` | `preconditionFailedError.reason`                          | Une précondition requise pour la requête n'a pas été satisfaite.                                                                    |
| `429 Too Many Requests`   | `QUOTA_ERROR`               | `quotaError.violations[]`                                 | Votre organisation a dépassé sa limite de débit. Voir [Limites de débit](#limites-de-debit).                                        |
| `503 Service Unavailable` | `TRANSIENT_ERROR`           | `transientError.reason`                                   | Un problème transitoire côté serveur a empêché le traitement de la requête. Peut être retenté avec un backoff.                      |

### Exemple : requête invalide

```json theme={null}
{
  "error": {
    "code": "BAD_REQUEST_ERROR",
    "details": {
      "badRequestError": {
        "fieldViolations": [
          {
            "field": "text",
            "message": "field is required"
          }
        ]
      }
    }
  }
}
```

### Exemple : échec d'authentification

```json theme={null}
{
  "error": {
    "code": "AUTHENTICATION_ERROR",
    "details": {
      "authenticationError": {
        "reason": "REASON_INVALID_CREDENTIALS"
      }
    }
  }
}
```

### Exemple : échec transitoire

```json theme={null}
{
  "error": {
    "code": "TRANSIENT_ERROR",
    "details": {
      "transientError": {
        "reason": "upstream service temporarily unavailable"
      }
    }
  }
}
```

Retentez les réponses `TRANSIENT_ERROR` avec un backoff exponentiel. Les autres codes d'erreur ne doivent pas être retentés sans avoir corrigé la cause sous-jacente.

## Étapes suivantes

<Card title="Concepts clés" icon="book-open" href="/fr/api-reference/concepts">
  Découvrez les éléments fondamentaux de l'API Bodyguard : organisations, sources, canaux, références et dates de publication.
</Card>
