---
url: 'https://www.corbado.com/fr/blog/webauthn-mediation-immediate-expliquee'
title: 'La médiation immédiate de WebAuthn expliquée'
description: 'Une analyse approfondie de la médiation immédiate de WebAuthn. Découvrez comment elle permet de créer un bouton de connexion unique, d''éviter les QR codes déroutants et de construire un flux de connexion plus intelligent.'
lang: 'fr'
author: 'Vincent Delitz'
date: '2025-08-08T11:43:10.563Z'
lastModified: '2026-08-28T12:00:53.914Z'
keywords: 'WebAuthn mediation immediate, médiation immédiate, connexion passkey, authentification webauthn'
category: 'WebAuthn Know-How'
---

# La médiation immédiate de WebAuthn expliquée

## 1. Introduction : Le paradoxe des Passkeys et le bouton de connexion unique

La transition vers les Passkeys crée un « paradoxe des Passkeys » : certains utilisateurs
ont des Passkeys, tandis que beaucoup utilisent encore des mots de passe traditionnels.
Cela conduit à des écrans de [connexion](https://www.corbado.com/fr/faq/connexion-second-appareil-cle-acces-liee)
surchargés avec plusieurs boutons : « Se connecter avec un
[mot de passe](https://www.corbado.com/fr/blog/comment-activer-passkeys-android) », « Se connecter avec Google »
et « Se connecter avec un Passkey ». Cette fragmentation crée des frictions. Un
utilisateur peut cliquer sur « Se connecter avec un Passkey » sur un nouvel appareil pour
se retrouver face à une invite de [QR code](https://www.corbado.com/blog/qr-code-login-authentication)
déroutante, car son Passkey n'est pas disponible localement. Le problème fondamental est
l'incapacité du site web à connaître le contexte de l'utilisateur avant de lancer un flux
d'[authentification](https://www.corbado.com/fr/blog/webauthn-relying-party-id-rpid-passkeys).

Une solution consiste à utiliser une approche « identifier-first » pour déterminer la
meilleure méthode de [connexion](https://www.corbado.com/fr/faq/connexion-second-appareil-cle-acces-liee) pour
l'utilisateur. Une autre solution potentielle est un bouton de
[connexion](https://www.corbado.com/fr/faq/connexion-second-appareil-cle-acces-liee) unique et intelligent qui
orchestre le flux le plus fluide pour chaque utilisateur. Il devrait directement proposer
un Passkey si celui-ci est disponible sur l'appareil, ou se rabattre élégamment sur
d'autres méthodes dans le cas contraire.

Une nouvelle fonctionnalité WebAuthn a été annoncée qui pourrait rendre cela possible : la
médiation immédiate (`mediation: 'immediate'`). En définissant cette propriété dans un
appel à l'API WebAuthn, les [développeurs](https://www.corbado.com/fr/blog/aide-memoire-cles-dacces) peuvent
créer une expérience de connexion intelligente et unifiée qui résout le paradoxe des
Passkeys. Cet article propose une analyse de `mediation: 'immediate'` axée sur les
[développeurs](https://www.corbado.com/fr/blog/aide-memoire-cles-dacces), en explorant ce que c'est, comment ça
fonctionne et comment l'implémenter.

## 2. Qu'est-ce que la médiation WebAuthn ?

Pour comprendre la médiation immédiate, il est utile de connaître d'abord les autres
options. **La médiation utilisateur dans WebAuthn est la manière dont le navigateur gère
l'interaction entre votre site web (la Partie de confiance ou Relying Party) et
l'authentificateur de l'utilisateur** (par exemple, [Face ID](https://www.corbado.com/faq/is-face-id-passkey),
[YubiKey](https://www.corbado.com/glossary/yubikey)).

### 2.1. Médiation modale (comportement par défaut)

C'est le flux WebAuthn classique et explicite. Lorsqu'une
[Partie de confiance](https://www.corbado.com/fr/glossary/relying-party) (Relying Party) appelle
`navigator.credentials.get()` sans spécifier de préférence de `mediation`, le navigateur
présente **toujours** une boîte de dialogue modale. Cette boîte de dialogue se superpose
au contenu de la page, exigeant l'attention immédiate de l'utilisateur et suspendant toute
autre interaction avec le site web.

- **Cas d'usage :** Idéal pour les boutons dédiés « Se connecter avec un Passkey » où
  l'utilisateur a clairement exprimé son intention.
- **Limite :** Si l'utilisateur n'a pas de Passkey sur l'appareil actuel, un flux
  multi-appareils lui est présenté (par exemple, un
  [QR code](https://www.corbado.com/blog/qr-code-login-authentication)), ce qui peut être une impasse déroutante.

### 2.2. Médiation conditionnelle : `mediation: 'conditional'`

Introduit pour aider les utilisateurs à passer aux Passkeys, ce mode est plus subtil. Avec
`mediation: 'conditional'`, la requête WebAuthn est attachée à un champ de saisie (par
exemple, le nom d'utilisateur) avec l'attribut `autocomplete="webauthn"`. Lorsque
l'utilisateur clique sur le champ, l'interface de
[remplissage automatique](https://www.corbado.com/fr/blog/webauthn-conditional-ui-remplissage-automatique-passkeys)
du navigateur suggère les Passkeys disponibles.

- **Cas d'usage :** Idéal pour améliorer progressivement les formulaires de connexion
  traditionnels, permettant aux utilisateurs de découvrir et d'utiliser les Passkeys sans
  bouton séparé.
- **Limite :** Il donne une priorité si stricte à la confidentialité que si l'utilisateur
  n'a pas de Passkey ou n'interagit pas avec l'invite, la promesse de l'appel API ne se
  résout _jamais_. Le site web ne reçoit aucun signal, ce qui rend impossible
  l'orchestration d'une interface de secours.

## 3. Qu'est-ce que la médiation immédiate ?

`mediation: 'immediate'` est la solution au problème du « bouton de connexion unique ».
Elle fournit un moyen fiable pour un site web de vérifier la disponibilité d'un Passkey
avant d'afficher une quelconque interface utilisateur.

### 3.1 Le concept de base : « Demander, ne pas imposer »

Au lieu d'_imposer_ à l'utilisateur de s'authentifier avec un Passkey via une modale, la
médiation `immediate` _demande_ au navigateur : « Y a-t-il un Passkey facilement
disponible pour cet utilisateur sur cet appareil _maintenant_ ? »

Point crucial, cette requête ne vérifie que les identifiants _disponibles localement_ (par
exemple, les authentificateurs intégrés à l'appareil comme
[Windows Hello](https://www.corbado.com/glossary/windows-hello) ou les Passkeys synchronisés via un gestionnaire
de mots de passe). Elle est conçue pour **éviter** de déclencher le flux multi-appareils
par [QR code](https://www.corbado.com/blog/qr-code-login-authentication), qui est un point de friction courant.

### 3.2 La logique à deux voies

La puissance de cette fonctionnalité réside dans son résultat clair et binaire. La
promesse retournée par `navigator.credentials.get()` réussira ou échouera, donnant au
développeur un signal clair.

- **Voie 1 (Succès) : Un identifiant existe.** Si le navigateur trouve un Passkey
  disponible localement, il contourne l'interface du site web et présente _immédiatement_
  sa propre modale native, comme un sélecteur de compte. Si l'utilisateur s'authentifie
  avec succès, la promesse se résout avec l'objet `PublicKeyCredential`.
- **Voie 2 (Échec) : Aucun identifiant n'existe.** Si le navigateur ne trouve aucun
  identifiant disponible localement, il n'affiche **aucune interface**. À la place, la
  promesse de `navigator.credentials.get()` est _immédiatement_ rejetée avec une
  `DOMException` nommée `NotAllowedError`.

### 3.3 Quels sont les avantages de la médiation immédiate ?

L'erreur `NotAllowedError` n'est pas un bug. C'est plutôt une fonctionnalité. C'est un
signal fiable et instantané indiquant que le site web doit passer à une méthode
d'[authentification](https://www.corbado.com/fr/blog/webauthn-relying-party-id-rpid-passkeys) de secours. Cela
permet aux [développeurs](https://www.corbado.com/fr/blog/aide-memoire-cles-dacces) d'utiliser un simple bloc
`try...catch` : le bloc `try` tente le flux Passkey fluide, et le bloc `catch` écoute
`NotAllowedError` pour afficher un formulaire de connexion traditionnel. Elle résout
élégamment le problème du bouton de connexion unique en créant un seul point d'entrée qui
s'adapte intelligemment au contexte de l'utilisateur.

## 4. Comparaison : Médiation immédiate, conditionnelle et modale

Choisir le bon mode de médiation est une décision UX essentielle. Ce tableau propose une
comparaison directe.

| Fonctionnalité / Comportement               | Modale (par défaut)                                              | UI conditionnelle (`conditional`)                                                                       | Immédiate (`immediate`)                                                                 |
| ------------------------------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
| **Appel API**                               | `navigator.credentials.get()`                                    | `navigator.credentials.get({ mediation: 'conditional' })`                                               | `navigator.credentials.get({ mediation: 'immediate' })`                                 |
| **Déclencheur**                             | Action explicite de l'utilisateur (ex: clic sur un bouton)       | Chargement de la page ; UI au focus sur le champ de saisie                                              | Action explicite de l'utilisateur (ex: clic sur un bouton)                              |
| **Présentation de l'UI**                    | Affiche **toujours** une boîte de dialogue modale immédiatement. | Affiche une UI non modale, de type remplissage automatique.                                             | Affiche une boîte de dialogue modale **uniquement si** un identifiant local est trouvé. |
| **Comportement si aucun identifiant local** | Affiche l'UI pour les flux multi-appareils (ex: QR code).        | La promesse reste en attente, ne se résout jamais, aucune erreur n'est levée.                           | La promesse est **immédiatement rejetée** avec `NotAllowedError`.                       |
| **Information pour le site**                | N'apprend rien tant que l'utilisateur n'a pas terminé le flux.   | N'apprend rien si l'utilisateur n'interagit pas. Confidentialité maximale.                              | Apprend une seule information (un bit) : l'existence d'un identifiant local.            |
| **Cas d'usage principal**                   | Bouton dédié « Se connecter avec un Passkey ». 2FA explicite.    | Formulaires de connexion/inscription unifiés. Amélioration progressive des formulaires de mot de passe. | Un bouton « Se connecter » unique et principal pour une base d'utilisateurs mixte.      |
| **Action du développeur**                   | Gérer le succès ou l'annulation par l'utilisateur.               | Gérer le succès. Aucun signal d'échec sur lequel agir.                                                  | Gérer le succès ou `NotAllowedError` pour déclencher une UI de secours.                 |

## 5. Comment implémenter la médiation immédiate

Voici un guide pratique, étape par étape, pour implémenter `mediation: 'immediate'`.

### 5.1. Étape 1 : Détection de la fonctionnalité

Comme `mediation: 'immediate'` est une nouvelle fonctionnalité, une
[détection](https://www.corbado.com/fr/blog/le-role-de-lia-dans-la-detection-des-cybermenaces) de fonctionnalité
robuste est cruciale.

```javascript
// La détection de fonctionnalité est essentielle pour l'amélioration progressive.
let immediateMediationAvailable = false;

if (window.PublicKeyCredential && PublicKeyCredential.getClientCapabilities) {
    try {
        const capabilities = await PublicKeyCredential.getClientCapabilities();
        // La capacité 'immediateGet' signale le support par le navigateur.
        immediateMediationAvailable = capabilities.immediateGet === true;
    } catch (e) {
        console.error("Erreur lors de l'obtention des capacités du client :", e);
    }
}
```

### 5.2 Étape 2 : L'appel `navigator.credentials.get()`

Cet appel doit être déclenché par un geste de l'utilisateur, comme le clic sur un bouton.

```javascript
// Cette fonction devrait être le gestionnaire d'événements pour votre bouton principal « Se connecter ».
async function handleSignInClick() {
    if (!immediateMediationAvailable) {
        // Se rabattre sur l'affichage d'un formulaire de connexion classique si la fonctionnalité n'est pas prise en charge.
        showLegacyLoginForm();
        return;
    }

    try {
        // Récupérez un nouveau challenge aléatoire depuis votre serveur pour chaque tentative.
        const challenge = await fetchChallengeFromServer();

        const publicKeyCredentialRequestOptions = {
            challenge: challenge, // Le challenge fourni par le serveur sous forme de Uint8Array
            rpId: "example.com",
            // La liste allowCredentials DOIT être vide pour la médiation immédiate
            // afin de protéger la vie privée de l'utilisateur.
            allowCredentials: [],
        };

        const credential = await navigator.credentials.get({
            publicKey: publicKeyCredentialRequestOptions,
            // C'est la clé qui active le flux de médiation immédiate.
            mediation: "immediate",
        });

        // Si la promesse se résout, envoyez l'identifiant à votre serveur pour vérification.
        await verifyCredentialOnServer(credential);
    } catch (error) {
        // Le bloc catch est une partie essentielle du flux de contrôle.
        handleAuthError(error);
    }
}
```

### 5.3 Étape 3 : Gérer `NotAllowedError` pour un repli élégant

Le bloc `catch` est l'endroit où l'« intelligence » du bouton de connexion unique se
concrétise.

```javascript
// La gestion de NotAllowedError est la clé du mécanisme de secours.
function handleAuthError(error) {
    // Vérifiez la propriété 'name' de la DOMException.
    if (error.name === "NotAllowedError") {
        // C'est le signal attendu pour afficher le formulaire de connexion traditionnel.
        console.log(
            "Aucun Passkey local trouvé. Affichage du formulaire de connexion classique.",
        );
        showLegacyLoginForm();
    } else {
        // Ceci gère d'autres erreurs potentielles, comme l'utilisateur qui ferme l'invite.
        console.error("Erreur d'authentification :", error);
    }
}
```

### 5.4 Étape 4 : Créer un flux unifié avec les mots de passe

Pour une expérience des plus fluides, vous pouvez demander au navigateur de rechercher à
la fois les Passkeys et les mots de passe enregistrés dans la même requête en ajoutant
`password: true`.

```javascript
// Combiner les Passkeys et les mots de passe pour une expérience de connexion vraiment unifiée.
const credential = await navigator.credentials.get({
    publicKey: publicKeyCredentialRequestOptions,
    password: true, // Demander au navigateur d'inclure les mots de passe enregistrés.
    mediation: "immediate",
});

// L'objet 'credential' retourné sera soit un PublicKeyCredential
// soit un PasswordCredential. Votre logique côté serveur doit gérer les deux.
```

### 5.5. Éviter les pièges courants

1. **Requêtes WebAuthn concurrentes :** Une requête `conditional` en attente (souvent
   lancée au chargement de la page) peut bloquer une nouvelle requête `immediate`.
   Envisagez d'utiliser un `AbortController` pour annuler toute requête en attente avant
   d'en lancer une nouvelle.
2. **La restriction `allowCredentials` :** Le tableau `allowCredentials` **doit** être
   vide. Fournir des ID d'identifiants entraînera l'échec de l'appel. C'est une protection
   de la vie privée cruciale pour empêcher les sites de vérifier la présence
   d'utilisateurs spécifiques et connus.
3. **L'exigence d'un geste de l'utilisateur :** L'appel doit être initié par un geste de
   l'utilisateur (par exemple, un événement 'click'). L'appeler de manière programmatique
   au chargement de la page sera bloqué par les navigateurs comme mesure de protection de
   la vie privée.

## 6. Sécurité et confidentialité de la médiation immédiate

`mediation: 'immediate'` a été conçue avec une compréhension claire de ses compromis en
matière de sécurité et de confidentialité.

### 6.1. La « fuite d'un bit » : reconnaître le compromis

Le compromis principal est une « fuite d'un bit ». En chronométrant la résolution de la
promesse, une [Partie de confiance](https://www.corbado.com/fr/glossary/relying-party) (Relying Party) peut
déduire une information d'un bit : si la promesse a été rejetée instantanément (pas
d'identifiant local) ou si elle a été retardée (une invite d'interface utilisateur a été
affichée car un identifiant local a été trouvé). Le but de cette fuite est de permettre
une meilleure expérience utilisateur.

### 6.2. Pourquoi c'est un risque acceptable : les garde-fous intégrés

Les concepteurs ont anticipé le potentiel d'abus (par exemple, le suivi des utilisateurs)
et ont intégré plusieurs garde-fous non négociables :

1. **Geste utilisateur obligatoire :** L'appel API doit être déclenché par une action de
   l'utilisateur, comme un clic. Cela empêche un site de sonder silencieusement les
   comptes au chargement de la page et rend le 'fingerprinting' à grande échelle peu
   pratique.
2. **Désactivé en mode de navigation privée/incognito :** La fonctionnalité est interdite
   dans les modes de navigation privée pour empêcher de lier l'activité d'un utilisateur
   entre les sessions normales et privées.
3. **Liste `allowCredentials` interdite :** Le tableau `allowCredentials` doit être vide.
   Cela empêche un site d'utiliser cette fonctionnalité pour vérifier si un utilisateur
   connu _spécifique_ est en visite.
4. **Contexte de première partie (first-party) uniquement :** La fonctionnalité est
   interdite dans des contextes tiers (par exemple, une `iframe` d'une autre origine) pour
   empêcher le suivi intersites.

Ces mesures d'atténuation garantissent que les garanties de sécurité fondamentales de
WebAuthn restent intactes. La cérémonie
d'[authentification](https://www.corbado.com/fr/blog/webauthn-relying-party-id-rpid-passkeys) elle-même est
inchangée et reste résistante au [phishing](https://www.corbado.com/glossary/phishing).

## 7. Support de la médiation immédiate par les navigateurs

`mediation: 'immediate'` est une fonctionnalité avancée de la
[spécification WebAuthn de niveau 3](https://w3c.github.io/webauthn/), et son déploiement
est en cours. À la mi-2025, une stratégie d'amélioration progressive est essentielle.

| Navigateur          | Statut                          | Notes et source                                                                                                                |
| ------------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| **Chrome**          | **Essai pour les développeurs** | Disponible via le flag `experimental-web-platform-features`. [Suivi du bug](https://issues.chromium.org/issues/408002783).     |
| **Edge**            | En développement (attendu)      | En tant que navigateur basé sur Chromium, le support devrait suivre celui de Chrome.                                           |
| **Safari (WebKit)** | À l'étude                       | [Positions de WebKit sur les standards](https://github.com/WebKit/standards-positions/issues/504). Aucun engagement public.    |
| **Firefox (Gecko)** | À l'étude                       | [Positions de Mozilla sur les standards](https://github.com/mozilla/standards-positions/issues/1239). Aucun engagement public. |

## 8. Médiation immédiate vs. Passkey Intelligence

Bien que `mediation: 'immediate'` fournisse un excellent outil de bas niveau pour un
bouton de connexion plus intelligent, il est important de le distinguer d'une solution
plus large de «
[Passkey Intelligence](https://docs.corbado.com/corbado-connect/features/passkey-intelligence)
», comme celle proposée par Corbado. Les deux visent à résoudre le paradoxe des Passkeys
et à augmenter leur adoption, mais ils le font de manières différentes.

| Caractéristique           | `mediation: 'immediate'`                                                                                 | Passkey Intelligence (ex: Corbado)                                                                                                                                                 |
| ------------------------- | -------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Fonctionnement**        | Un appel API natif du navigateur qui vérifie les Passkeys disponibles localement sur l'appareil actuel.  | Un service backend qui collecte et analyse des données sur les appareils des utilisateurs, les authentificateurs et l'historique de connexion à travers les sessions.              |
| **Signal fourni**         | Un signal simple et binaire : un Passkey local existe (invite `UI`) ou n'existe pas (`NotAllowedError`). | Des informations riches et contextuelles, par exemple : « Cet utilisateur vient de se connecter avec un mot de passe sur un appareil compatible Passkey qu'il utilise souvent. »   |
| **Avantage clé**          | Vérification native très rapide avec une surcharge réseau minimale.                                      | Disponibilité universelle, indépendante du support des nouvelles fonctionnalités WebAuthn par le navigateur/OS. Des informations plus approfondies pour une UX plus personnalisée. |
| **Dépendance principale** | Nécessite un support à jour du navigateur et de l'OS, ce qui n'est pas encore universel.                 | Intégration avec un service backend.                                                                                                                                               |

La **Passkey Intelligence** va plus loin en collectant et en évaluant des données au fil
du temps. Cela permet des interventions utilisateur plus sophistiquées et opportunes. Par
exemple, un backend de
[Passkey Intelligence](https://docs.corbado.com/corbado-connect/features/passkey-intelligence)
peut détecter :

- Un utilisateur s'authentifiant avec succès avec un
  [mot de passe](https://www.corbado.com/fr/blog/comment-activer-passkeys-android) sur un nouvel appareil
  compatible Passkey et l'inviter à ajouter un Passkey pour la prochaine fois.
- Un utilisateur terminant une connexion « hybride » multi-appareils et lui suggérer
  immédiatement d'enregistrer le nouvel appareil.
- Un utilisateur échouant à se connecter sur un nouvel appareil et lui proposer la
  création d'un Passkey comme option de récupération ou de configuration (réparation
  automatique).

Cette approche basée sur les données est indépendante du support de
`mediation: 'immediate'` par le navigateur, ce qui signifie qu'elle peut fournir un flux
de connexion plus intelligent pour tous vos utilisateurs, dès maintenant.

**Le meilleur des deux mondes**

En fin de compte, ces deux approches ne s'excluent pas mutuellement ; elles sont
complémentaires. La solution idéale les combine :

1. Utiliser un service de **Passkey Intelligence** comme cerveau de votre processus de
   connexion.
2. Le service peut ensuite utiliser `mediation: 'immediate'` comme l'un de ses signaux sur
   les navigateurs compatibles pour effectuer une vérification initiale rapide.
3. En fonction du résultat — ou de l'absence de support pour la fonctionnalité — le
   service d'intelligence peut alors utiliser ses données historiques plus riches pour
   orchestrer le repli parfait, que ce soit en affichant un champ de
   [mot de passe](https://www.corbado.com/fr/blog/comment-activer-passkeys-android) ou en proposant une invite de
   création de Passkey juste à temps.

En combinant la vitesse native de `mediation: 'immediate'` avec les informations
approfondies d'un backend de
[Passkey Intelligence](https://docs.corbado.com/corbado-connect/features/passkey-intelligence),
vous pouvez offrir l'expérience de connexion la plus fluide, adaptative et efficace
possible, guidant en douceur chaque utilisateur vers un avenir
[sans mot de passe](https://www.corbado.com/fr/blog/comment-passer-totalement-sans-mot-de-passe).

## 9. L'impact commercial de la médiation immédiate

La médiation immédiate est une excellente amélioration de l'expérience de connexion. Elle
fournit l'intelligence nécessaire pour éliminer les points de friction et de confusion
courants pour les utilisateurs pendant la transition vers les Passkeys.

- **Réduit la confusion de l'utilisateur :** En permettant un seul bouton « Se connecter
  », la médiation `immediate` supprime la charge cognitive pour l'utilisateur. Il n'a plus
  à se souvenir de la méthode d'authentification qu'il a configurée ni à choisir dans une
  liste d'options surchargée. Le processus de connexion devient plus simple et plus
  intuitif.
- **Évite les abandons de connexion par Passkey :** Une raison courante pour laquelle les
  utilisateurs abandonnent une connexion par Passkey est l'apparition inattendue d'un QR
  code pour un flux multi-appareils. Comme `mediation: 'immediate'` ne recherche que les
  identifiants locaux, elle évite complètement cette situation déroutante. Au lieu que
  l'utilisateur abandonne le flux, l'application reçoit un signal clair
  (`NotAllowedError`) pour se rabattre élégamment sur une autre méthode, ce qui se traduit
  par un parcours plus fluide.
- **Crée un flux fluide et intelligent :** L'avantage principal est une expérience de
  connexion intelligente. L'application peut demander au navigateur si une connexion par
  Passkey fluide est possible avant de s'engager dans une interface utilisateur. Cette
  approche « Demander, ne pas imposer » garantit que les utilisateurs ne voient que des
  invites pertinentes pour eux. La connexion semble ainsi intelligente et adaptative,
  renforçant la commodité des Passkeys et encourageant leur utilisation continue.

## 10. Conclusion : La médiation immédiate

La médiation immédiate est une nouvelle fonctionnalité de WebAuthn qui résout l'expérience
de connexion fragmentée de la période de transition vers les Passkeys. Elle permet de
créer un bouton « Se connecter » unique et intelligent qui s'adapte au contexte de
l'utilisateur, éliminant ainsi la confusion et les frictions.

Bien qu'elle introduise un compromis calculé en matière de confidentialité, elle inclut
des garde-fous robustes pour atténuer les risques sans compromettre la sécurité
fondamentale de WebAuthn.

Pour les développeurs, la voie à suivre est l'amélioration progressive. Construisez une
expérience de base solide et ajoutez la médiation `immediate` par-dessus pour les
navigateurs compatibles. Adopter cette fonctionnalité est une décision stratégique pour
accélérer l'adoption des Passkeys, renforcer la sécurité, réduire les
[co](https://www.corbado.com/fr/blog/conformite-cybersecurite)ûts opérationnels et améliorer la conversion.

L'[implémentation](https://www.corbado.com/fr/blog/aide-memoire-cles-dacces) de ces flux d'authentification
avancés peut être complexe. La plateforme Passkey Entreprise de Corbado élimine cette
complexité. Notre infrastructure gère l'orchestration optimale des flux, y compris la
médiation conditionnelle et `immediate`, permettant à votre équipe de déployer en toute
confiance une expérience d'authentification de pointe et sans friction.
