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

> Décrit comment implémenter l’authentification Passwordless à l’aide des API Auth0.

# Utilisation des API Passwordless

export const ReleaseStageNotice = ({feature, stage, plans, contact, terms}) => {
  const stageTextMap = {
    "beta": "bêta",
    "ea": "Accès anticipé"
  };
  const stageText = stageTextMap[stage] || "une phase de lancement du produit";
  const prsLink = "/docs/troubleshoot/product-lifecycle/product-release-stages";
  const linkify = (text, url) => {
    return <a href={url} target="_blank" rel="noreferrer" class="link">{text}</a>;
  };
  const includeDetails = (plans, contact, terms) => {
    const hasDetails = terms || plans || contact;
    if (!hasDetails) return null;
    return <span data-as="p">
            {plans && <>Cette fonctionnalité est offerte avec les forfaits {linkify(`${plans}`, "https://auth0.com/pricing")}. </>}
            {contact && "Pour y participer, communiquez avec " + contact + ". "}
            {terms && <>En utilisant cette fonctionnalité, vous acceptez les conditions applicables de l’essai gratuit énoncées dans le {linkify("Master Subscription Agreement", "https://www.okta.com/legal")} d’Okta.</>}
        </span>;
  };
  return <Warning>
            <span data-as="p">
                <strong>La fonctionnalité {feature} est en {linkify(stageText, prsLink)}.</strong>
            </span>

            {includeDetails(plans, contact, terms)}
        </Warning>;
};

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Les API <Tooltip tip="Passwordless : forme d’authentification sans mot de passe comme premier facteur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Passwordless">Passwordless</Tooltip> peuvent être utilisées dans deux scénarios :

* Lorsque vous implémentez <Tooltip tip="Universal Login : votre application redirige vers Universal Login, hébergé sur le serveur d’autorisation d’Auth0, pour vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Universal+Login">Universal Login</Tooltip> et que vous souhaitez personnaliser la page de connexion à l’aide d’auth0.js pour interagir avec Auth0.
* Lorsque vous souhaitez intégrer le flux de connexion à votre application.

Pour en savoir plus sur la façon d’implémenter Passwordless avec Universal Login et Embedded Login dans différents scénarios, consultez [Passwordless Authentication with Universal Login](/docs/fr-ca/authenticate/passwordless/implement-login/universal-login) ou [Passwordless Authentication with Embedded Login](/docs/fr-ca/authenticate/passwordless/implement-login/embedded-login).

<div id="passwordless-endpoints">
  ## Points de terminaison de Passwordless
</div>

<div id="post-passwordlessstart">
  ### POST /passwordless/start
</div>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Vous devez activer l’octroi **Passwordless OTP** dans les paramètres de votre application, à [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications), sous **Advanced Settings** > **Grant Types**.
</Callout>

Le point de terminaison [POST /passwordless/start](https://auth0.com/docs/api/authentication#get-code-or-link) permet de lancer le processus d’authentification Passwordless pour Classic Login et Embedded Login.

Selon les paramètres fournis au point de terminaison, Auth0 amorce le processus de vérification de l’utilisateur en envoyant l’un des éléments suivants :

* Un code à usage unique par courriel ou par SMS
* Un lien à usage unique par courriel

L’appel d’API doit avoir la structure suivante :

export const codeExample1 = `POST https://{yourDomain}/passwordless/start
Content-Type: application/json
{
  "client_id": "{yourClientID}",
  "client_secret": "{yourClientSecret}", // Pour les Applications Web régulières
  "connection": "email|sms",
  "email": "{email}", //à définir si connection=email
  "phone_number": "{phoneNumber}", //à définir si connection=sms
  "send": "link|code", //si la valeur est null, link est utilisé par défaut
  "authParams": { // tout paramètre d’authentification que vous souhaitez ajouter
    "scope": "openid",     // utilisé lors de la demande d’un Magic Link
    "state": "{yourState}"  // utilisé lors de la demande d’un Magic Link ou depuis la page de connexion personnalisée
  }
}`;

<AuthCodeBlock children={codeExample1} language="json" />

Si vous utilisez un lien magique, les utilisateurs recevront un lien généré par l’Authentication API. Ils cliqueront sur ce lien, ce qui déclenchera une requête vers \{`yourAuth0Tenant}.auth0.com/passwordless/verify-redirect`. Auth0 redirigera ensuite l’utilisateur vers l’application, où il sera connecté.

Si vous utilisez un code, votre application devra demander à l’utilisateur de le saisir, puis vous devrez utiliser le point de terminaison `/oauth/token` ou la méthode `passwordlessLogin` du SDK Auth0.js pour échanger ce code contre des jetons d’authentification.

<div id="post-oauthtoken">
  ### POST /oauth/token
</div>

Si vous implémentez Passwordless pour les Native Applications ou les Regular Web Applications, vous devez utiliser `/oauth/token` pour échanger le code OTP contre des jetons d’authentification. Vous ne pouvez pas utiliser ce point de terminaison à partir des applications monopages.

Pour ce faire, vous devez d’abord activer l’octroi **Passwordless OTP** pour votre application dans [Auth0 Dashboard > Applications > Applications](https://manage.auth0.com/#/applications), sous **Advanced Settings** > **Grant Types** dans les paramètres de votre application.

L’utilisateur recevra le code OTP et votre Native ou Web application lui demandera de le saisir. Lorsque l’utilisateur saisit le code, vous pouvez terminer le flux d’authentification en appelant le point de terminaison `/oauth/token` avec les paramètres suivants :

export const codeExample2 = `POST https://{yourAuth0Domain}/oauth/token
Content-Type: application/json
{
  "grant_type" : "http://auth0.com/oauth/grant-type/passwordless/otp",
  "client_id": "{yourAuth0ClientID}",
  "client_secret": "{yourClientSecret}", // seulement pour les applications Web; les applications natives n’ont pas de secret client
  "username":"<adresse courriel>", // ou "<numéro de téléphone>"
  "otp": "CODE",
  "realm": "email", // ou "sms" 
  "audience" : "your-api-audience", // si vous avez besoin d’un jeton d’accès pour une API précise
  "scope": "openid profile email" // selon les portées dont vous avez besoin
}`;

<AuthCodeBlock children={codeExample2} language="json" />

Si tout se passe bien, Auth0 renverra une réponse comme la suivante :

```json lines theme={null}
HTTP/1.1 200 OK
Content-Type: application/json
{
"access_token":"eyJz93a...k4laUWw",
"refresh_token":"GEbRxBN...edjnXbL",
"id_token":"eyJ0XAi...4faeEoQ",
"token_type":"Bearer",
"expires_in":86400
}
```

Vous pouvez ensuite décoder le <Tooltip tip="ID Token : information d’authentification destinée au client lui-même, plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=ID+Token">ID Token</Tooltip> pour obtenir des renseignements sur l’utilisateur, ou utiliser le <Tooltip tip="Access Token : information d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Access+Token">Access Token</Tooltip> pour appeler votre API comme d’habitude.

<div id="using-auth0js">
  ## Utilisation d'Auth0.js
</div>

Pour mettre en œuvre l'authentification Passwordless dans des applications monopages ou sur une page Universal Login personnalisée, nous vous recommandons [d'utiliser Auth0.js et la méthode `passwordlessLogin` incluse](/docs/fr-ca/libraries/auth0js). La mise en œuvre est complexe; nous vous recommandons donc d'utiliser la bibliothèque plutôt que d'effectuer des requêtes API directement.

<div id="rate-limiting-in-passwordless-endpoints">
  ## Limitation du débit dans les points de terminaison Passwordless
</div>

Les limites de débit d’Auth0 et les fonctionnalités de <Tooltip tip="Protection contre les attaques : fonctionnalités qu’Auth0 offre pour détecter et atténuer les attaques, y compris la protection contre les attaques par force brute, la limitation du trafic provenant d’IP suspectes, la détection des mots de passe compromis, la détection de bots et l’authentification multifacteur adaptative." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=attack+protection">protection contre les attaques</Tooltip> ne tiennent compte que de l’adresse IP de la machine qui effectue l’appel d’API. Lorsque l’appel d’API est effectué à partir d’un serveur backend, vous voulez habituellement qu’Auth0 tienne compte de l’adresse IP de l’utilisateur final, et non de celle du serveur.

Auth0 permet de spécifier un en-tête `auth0-forwarded-for` dans les appels d’API, mais il n’est pris en compte que lorsque :

* l’appel d’API est effectué pour une application confidentielle.
* l’appel d’API inclut le <Tooltip tip="Secret client : secret utilisé par un client (application) pour s’authentifier auprès du serveur d’autorisation; il ne devrait être connu que du client et du serveur d’autorisation et doit être suffisamment aléatoire pour ne pas pouvoir être deviné." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=client+secret">secret client</Tooltip>.
* la bascule **Faire confiance à l’en-tête IP du <Tooltip tip="Point de terminaison de jeton : point de terminaison du serveur d’autorisation utilisé pour demander des jetons par programmation." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Token+Endpoint">point de terminaison de jeton</Tooltip>** est activée.

Pour une explication complète, consultez [Éviter les problèmes courants liés au flux Resource Owner Password Flow et à la protection contre les attaques](/docs/fr-ca/get-started/authentication-and-authorization-flow/resource-owner-password-flow/avoid-common-issues-with-resource-owner-password-flow-and-attack-protection).

<div id="customize-mfa">
  ## Personnaliser l’authentification multifacteur
</div>

<ReleaseStageNotice feature="MFA personnalisable avec les flux Resource Owner Password Grant, Embedded ou Refresh Token" stage="ea" terms="true" contact="Auth0 Support" />

Personnalisez <Tooltip tip="Authentification multifacteur (MFA) : processus d’authentification de l’utilisateur qui utilise un facteur en plus du nom d’utilisateur et du mot de passe, comme un code par SMS." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=MFA">MFA</Tooltip> avec l’API Passwordless. Lorsque votre application appelle le point de terminaison `/oauth/token` pour demander un jeton d’accès, le <Tooltip tip="Serveur d’autorisation : serveur centralisé qui contribue à définir les limites de l’accès d’un utilisateur. Par exemple, votre serveur d’autorisation peut contrôler les données, les tâches et les fonctionnalités offertes à un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=authorization+server">serveur d’autorisation</Tooltip> renvoie une erreur `mfa_required`, qui fournit :

* Le `mfa_token` dont vous avez besoin pour appeler l’API MFA aux fins d’inscription et de vérifications.

* Le paramètre `mfa_requirements`, qui indique le `type` de facteur que votre application prend en charge pour les vérifications.

```json lines theme={null}
{
  "error": "mfa_required",
  "error_description": "Multifactor authentication required",
  "mfa_token": "Fe26...Ha",
  "mfa_requirements": {
    "challenge": [
      { "type": "otp" },
      { "type": "push-notification" },
      { "type": "phone" },
      { "type": "recovery-code" }
    ]
  }
}
```

Utilisez le `mfa_token` pour effectuer une requête vers le point de terminaison [`mfa/authenticator`](https://auth0.com/docs/api/authentication/muti-factor-authentication/list-authenticators) afin de répertorier tous les facteurs que l’utilisateur a déjà configurés et de repérer le même `type` que votre application prend en charge. Vous devez également obtenir le `authenticator_type` correspondant pour émettre des demandes de vérification :

```json lines theme={null}
[
  {
    "type": "recovery-code",
    "id": "recovery-code|dev_qpOkGUOxBpw6R16t",
    "authenticator_type": "recovery-code",
    "active": true
  },
  {
    "type": "otp",
    "id": "totp|dev_6NWz8awwC8brh2dN",
    "authenticator_type": "otp",
    "active": true
  }
]
```

Appliquez la vérification MFA en appelant le point de terminaison [`request/mfa/challenge`](https://auth0.com/docs/api/authentication/muti-factor-authentication/request-mfa-challenge).

Personnalisez davantage votre flux MFA avec Auth0 Actions. Pour en savoir plus, consultez [Déclencheurs des Actions : post-challenge - Objet API](/docs/fr-ca/customize/actions/explore-triggers/password-reset-triggers/post-challenge-trigger/post-challenge-api-object).