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

# Configurer Didit Authentication par API

> Configurez Didit Authentication par API : méthodes de connexion, paramètres, image de marque et protection, via accord approuvé ou clé dédiée.

Didit Authentication vous permet d'activer des méthodes de connexion et de récupérer les paramètres de votre application via l'API. Utilisez une autorisation approuvée par le propriétaire ou une clé API nommée avec la portée `authentication`.

> [!WARNING]
>
> L'authentification est une nouveauté. Configurez d'abord une méthode dans une application sandbox, puis dans votre application de production.

Chaque appel ci-dessous est envoyé à l'API de gestion de l'authentification de votre application. `MANAGEMENT_BASE` correspond à :

```text theme={null}
https://apx.didit.me/auth/v2/organizations/{org_id}/applications/{application_id}/authentication/
```

Les mêmes routes sont décrites dans `openapi-authentication.json`, sous le tag `Setup`, à partir duquel les SDK serveur sont régénérés.

## Quel moyen d'authentification utiliser

Chacun des trois identifiants suivants fonctionne, et chacun est limité à ce que son titulaire a approuvé.

| Identifiant | Envoyé sous la forme | Ce qu'il permet de faire |
| - | - | - |
| Clé API nommée avec la portée `authentication` | `x-api-key: <key>` | Configure sa propre application et la lit. Une clé avec `read` ne peut que lire la configuration ; `write` permet de la lire et de la modifier. |
| Autorisation approuvée par le titulaire avec `didit:management` | `Authorization: Bearer <access_token>` | Configure les applications des organisations approuvées lors du consentement, dans le cadre du rôle de la personne. |
| Session de la console | `Authorization: Bearer <console session token>` | Lit ou modifie les paramètres selon l'appartenance de la personne à l'organisation et son rôle. Les vues destinées à l'utilisateur final exigent aussi une session de la console et les autorisations appropriées. |

Ces identifiants sont refusés avec `403` sur toutes les routes de configuration, quelle que soit la requête :

* Le **secret principal** de l'application.
* Un jeton issu de `POST /programmatic/login`, qui est émis pour l'application et non pour la console.
* Une clé **sans** la portée `authentication`, y compris une clé créée avec toutes les ressources à leur niveau le plus élevé : ces clés sont affichées comme ayant un accès complet, gardent `scopes` vide et ne sont pas acceptées sur ces routes.
* Une clé d'**une autre application**, une autorisation limitée à `didit:verification`, ou une autorisation approuvée pour une autre organisation.

Une requête sans aucun identifiant renvoie `401`. Une autorisation ou une clé conserve en plus ses propres limites : l'autorisation est limitée par ses portées, ses organisations et le rôle de la personne ; la clé est limitée par ses portées, sa liste d'autorisation IP et sa date d'expiration.

## Approuver l'accès

### Avec une clé API nommée

Ouvrez **Developers -> API keys** dans la [Business Console](https://business.didit.me) et créez une clé pour l'application que vous configurez. Attribuez-lui la ressource `authentication` avec le droit **read** ou **write** : **read** couvre tous les appels qui lisent la configuration (`GET`) ; **write** couvre tous les appels qui la modifient (`POST`, `PUT`, `PATCH`, `DELETE`) et permet aussi de la lire. Consultez [Clés API](https://docs.didit.me/fr/console/api-keys.md) pour l'expiration, les listes d'adresses IP autorisées et la rotation : une clé appartient à une seule application et ne fonctionne que pour celle-ci.

### Via une connexion MCP

Un agent connecté au serveur MCP de Didit utilise l'autorisation que son propriétaire a approuvée sur l'écran de consentement, avec `didit:management`. Consultez [Authentification MCP](https://docs.didit.me/fr/integration/mcp/authentication.md#se-connecter-avec-didit).

### Pour un propriétaire sans mot de passe

Le flux d'autorisation par code d'appareil ([RFC 8628](https://datatracker.ietf.org/doc/html/rfc8628)) permet à un propriétaire qui se connecte avec Google, une clé d'accès ou un code envoyé par e-mail d'approuver le même accès depuis n'importe quel navigateur, sans saisir de mot de passe. Consultez [se connecter sans navigateur](https://docs.didit.me/fr/integration/mcp/authentication.md#se-connecter-sans-navigateur-code-d’appareil).

## Activer le code par e-mail

`PUT methods/{name}/` accepte `enabled`, et rien d'autre pour une méthode qui ne nécessite aucune information d'identification.

```bash theme={null}
curl --fail-with-body --request PUT "${MANAGEMENT_BASE}methods/code/" \
  -H "x-api-key: $DIDIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"enabled": true}'
```

Elle renvoie la méthode dans son état actuel :

```json theme={null}
{"name": "code", "enabled": true}
```

Lorsque vous relisez la configuration, l'entrée du code par e-mail contient `credential_source: null`. Les méthodes toujours activées ne peuvent pas être désactivées : cette requête renvoie `{"enabled": "always_on"}`.

## Activer Google

Une méthode de connexion sociale utilise les identifiants de votre propre application OAuth, ou ceux de l'application de test de Didit sur une application sandbox.

### Avec votre propre application Google

```bash theme={null}
curl --fail-with-body --request PUT "${MANAGEMENT_BASE}methods/google/" \
  -H "x-api-key: $DIDIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"enabled": true, "credentials": {"client_id": "1234.apps.googleusercontent.com", "client_secret": "GOCSPX-..."}}'
```

Enregistrez le `callback_uri` renvoyé par la réponse auprès de votre fournisseur. Le secret est en écriture seule : aucune réponse ne le renvoie, et `client_id` est la seule partie que vous pouvez relire. Activer une méthode sans identifiants, alors qu'aucun n'a été enregistré auparavant, renvoie `{"credentials": "required"}`.

### Avec l'application de test de Didit (`didit_test`)

Une **application sandbox** peut utiliser les applications sociales de Didit à la place des vôtres, ce qui suffit pour finaliser une configuration et vérifier qu'elle fonctionne :

```bash theme={null}
curl --fail-with-body --request PUT "${MANAGEMENT_BASE}methods/google/" \
  -H "x-api-key: $DIDIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"enabled": true, "credential_source": "didit_test"}'
```

`didit_test` couvre **Google, Microsoft, Apple et GitHub**, uniquement sur les applications sandbox :

| Réponse | Quand |
| - | - |
| `{"credential_source": "sandbox_only"}` | L'application est en production. Les applications de test ne prennent jamais en charge les connexions en production. |
| `{"credential_source": "unavailable"}` | Le déploiement ne dispose pas d'application de test pour ce fournisseur, donc la méthode reste désactivée. |
| `200` avec `configured: true` | L'application de test prend en charge la méthode, et la connexion hébergée la propose. |

`GET` sur la configuration indique les fournisseurs qu'une application de test peut prendre en charge pour cette application dans `didit_test_credentials`, avec la valeur `false` pour les quatre sur une application en production.

## Relire la configuration

`GET` sur `MANAGEMENT_BASE` permet de relire la configuration : chaque méthode avec `enabled` et `credential_source`, ainsi que les URL de rappel, les règles de session et la politique d'inscription.

```bash theme={null}
curl --fail-with-body "$MANAGEMENT_BASE" -H "x-api-key: $DIDIT_API_KEY"
```

```json theme={null}
{
  "enabled": true,
  "methods": [
    {"name": "code", "enabled": true, "credential_source": null},
    {"name": "google", "enabled": true, "credential_source": "didit_test", "configured": true, "client_id": "didit-test-google"},
    {"name": "password", "enabled": false, "credential_source": null}
  ],
  "didit_test_credentials": {"google": true, "microsoft": true, "apple": true, "github": true},
  "redirect_uris": ["https://app.example.com/auth/callback"]
}
```

Les méthodes désactivées sont aussi listées, si bien qu'un seul `GET` indique ce qui est activé et ce qui ne l'est pas. `enabled` en haut vaut `false` lorsque l'authentification est désactivée pour l'application. Toute modification de configuration effectuée avec une autorisation de gestion ou une clé nommée renvoie alors `409` avec `{"detail": "product_disabled"}`, et rien n'est écrit. Aucun appel de configuration n'active l'authentification : une personne l'active pour l'application dans la console, et vos appels fonctionnent à partir de ce moment-là.

## Le reste de la configuration

| Route, sous `MANAGEMENT_BASE` | Méthodes | Contenu |
| - | - | - |
| `settings/` | `GET`, `PATCH` | L'accès des agents, les organisations, la politique MFA, le rôle de membre par défaut, les événements webhook désactivés |
| `onboarding/` | `GET`, `PATCH` | Les étapes de configuration terminées, et si les utilisateurs se connectent sur la page hébergée ou sur vos propres écrans |
| `branding/` | `GET`, `PATCH` | Les textes des pages hébergées et les liens juridiques (le logo et les couleurs proviennent de Personnalisation) |
| `protection/` | `GET`, `PATCH` | Les politiques de [protection contre les bots](https://docs.didit.me/fr/authentication/bot-protection.md) |
| `verified/` | `GET`, `PATCH` | Le niveau de vérification à l'inscription, les règles d'élévation de niveau et les revendications du token |
| `emails/`, `emails/{key}/` | `GET` | Les e-mails de connexion envoyés par cette application, et un aperçu généré |
| `domain/` | `GET`, `PUT`, `DELETE` | L'origine hébergée et le domaine de connexion personnalisé |
| `domain/verify/`, `domain/activate/` | `POST` | Vérifie le DNS et le certificat du domaine, puis en fait l'origine canonique |
| `native-apps/` | `GET`, `PUT` | Les applications iOS et Android qui partagent les clés d'accès de l'application |

Une autorisation ou une clé API donne accès à la configuration et à ses compteurs, jamais aux données des utilisateurs finaux : `users/`, `sessions/`, `sign-ins/`, `overview/`, les organisations clientes, les rôles, les imports, les sessions d'agent et les e-mails de test nécessitent toujours une session de console.

Le paramètre `agent_humans_only` s'applique à l'application entière. Seul un propriétaire ou un administrateur de l'organisation peut le modifier. Une clé API nommée reçoit `403 owner_or_admin_required`. Activer ce paramètre exige également une clé d'accès enregistrée (`passkey_required`).

## Erreurs

| Réponse | Signification |
| - | - |
| `401` | Aucun identifiant. |
| `403` | Un identifiant qui ne peut pas configurer cette application, ou l'une de ses propres limites : `ip_not_allowed`, une clé expirée, une clé en lecture seule sur une route d'écriture. |
| `409 {"detail": "product_disabled"}` | L'authentification est désactivée pour l'application, donc une modification de configuration effectuée avec une autorisation ou une clé est refusée. Une personne l'active dans la console. |
| `400 {"<field>": "<code>"}` | `sandbox_only`, `unavailable`, `not_supported`, `required`, `always_on`, `method_unavailable`, `unknown_field`. |
| `404` | La ressource demandée est introuvable. |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.