> ## 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 d’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 étape du cycle de publication";
  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 {linkify(`${plans} forfaits`, "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) + "*****MASKED*****";
          }
          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>;
};

<Tooltip tip="Passwordless : forme d’authentification qui ne repose pas sur un mot de passe comme premier facteur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Passwordless">Passwordless</Tooltip> Les API 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="/fr-CA/docs/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 l’implémentation de Passwordless avec Universal Login et de la connexion intégrée dans différents scénarios, consultez [Authentification Passwordless avec Universal Login](/fr-CA/docs/authenticate/passwordless/implement-login/universal-login) ou [Authentification Passwordless avec connexion intégrée](/fr-CA/docs/authenticate/passwordless/implement-login/embedded-login).

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

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

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

Le point de terminaison [POST /passwordless/start](https://auth0.com/docs/api/authentication#get-code-or-link) peut être utilisé pour amorcer le processus d’authentification Passwordless pour Classic Login et connexion intégrée.

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 à l’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 classiques
  "connection": "email|sms",
  "email": "{email}", // à définir pour connection=email
  "phone_number": "{phoneNumber}", // à définir pour 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é pour demander un lien magique
    "state": "{yourState}"  // utilisé pour demander un lien magique, 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 un appel à \{`yourAuth0Tenant}.auth0.com/passwordless/verify-redirect`. Auth0 redirigera l’utilisateur vers l’application, et celui-ci sera connecté.

Si vous utilisez un code, votre application devra inviter l’utilisateur à saisir ce code, 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 des applications natives ou des applications Web classiques, 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 d’applications monopage.

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

L’utilisateur recevra le code OTP et votre application native ou Web l’invitera à le saisir. Lorsque l’utilisateur entre 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 particulière
  "scope": "openid profile email" // selon les scopes dont vous avez besoin
}`;

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

Si tout se passe bien, Auth0 renverra une réponse semblable à celle-ci :

```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’identification destinée à l’application cliente elle-même, plutôt qu’à l’accès à une ressource." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=ID+Token">ID Token</Tooltip> pour obtenir des informations sur l’utilisateur, ou utiliser le <Tooltip tip="Jeton d’accès : 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="/fr-CA/docs/glossary?term=Access+Token">Jeton d’accès</Tooltip> pour appeler votre API comme d’habitude.

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

Lorsque vous implémentez 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](/fr-CA/docs/libraries/auth0js). L’implémentation est complexe; nous vous recommandons donc d’utiliser la bibliothèque plutôt que d’appeler directement les API.

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

Les fonctionnalités de limitation du débit et 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 la force brute, la limitation des IP suspectes, la détection des mots de passe compromis, la détection des robots et l’authentification multifacteur adaptative." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=attack+protection">protection contre les attaques</Tooltip> d’Auth0 ne tiennent compte que de l’adresse IP de la machine à l’origine de l’appel d’API. Lorsque l’appel d’API provient d’un serveur backend, vous voulez généralement 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 une application pour s’authentifier auprès du serveur d’autorisation; il ne doit être connu que de l’application et du serveur d’autorisation et doit être suffisamment aléatoire pour ne pas pouvoir être deviné." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=client+secret">Secret client</Tooltip>.
* le bouton 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="/fr-CA/docs/glossary?term=Token+Endpoint">point de terminaison de jeton</Tooltip>** est activé.

Pour une explication complète, consultez [Éviter les problèmes courants avec le flux de mot de passe du propriétaire de la ressource et la protection contre les attaques](/fr-CA/docs/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 MFA
</div>

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

Personnalisez la <Tooltip tip="Authentification multifacteur (MFA) : processus d’authentification de l’utilisateur qui utilise un facteur supplémentaire en plus du nom d’utilisateur et du mot de passe, comme un code envoyé par SMS." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=MFA">MFA</Tooltip> à l’aide de 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 auxquelles un utilisateur a accès." cta="Voir le glossaire" href="/fr-CA/docs/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 pour l’inscription et les demandes de vérification.

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

```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 appeler le point de terminaison [`mfa/authenticator`](https://auth0.com/docs/api/authentication/muti-factor-authentication/list-authenticators) afin de répertorier tous les facteurs auxquels l’utilisateur est inscrit et de repérer le même `type` que celui pris en charge par votre application. Vous devez également obtenir le `authenticator_type` correspondant pour lancer 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
  }
]
```

Forcez la demande 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 les Actions d’Auth0. Pour en savoir plus, consultez [Déclencheurs des Actions : post-challenge - objet API](/fr-CA/docs/customize/actions/explore-triggers/password-reset-triggers/post-challenge-trigger/post-challenge-api-object).