> ## 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 gérer les inscriptions des facteurs d’authentification MFA pour les applications à l’aide de l’Auth0 MFA API.

# Gérer les facteurs d’authentification avec l’Authentication API

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
              processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

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>;
};

<Card title="Avant de commencer">
  * Activez le type d’octroi **MFA** pour votre application. Pour en savoir plus, consultez [Mettre à jour les type d’octroi](/docs/fr-ca/get-started/applications/update-grant-types).
</Card>

Auth0 fournit plusieurs [points de terminaison d’API](https://auth0.com/docs/api/authentication#multi-factor-authentication) pour vous aider à gérer les authentificateurs utilisés avec une application pour l’<Tooltip tip="Authentification multifacteur (MFA) : processus d’authentification de l’utilisateur qui utilise un facteur en plus du nom d’utilisateur et mot de passe, comme un code envoyé par SMS." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=multi-factor+authentication">authentification multifacteur</Tooltip> (MFA). Vous pouvez utiliser ces points de terminaison pour créer une interface utilisateur complète permettant aux utilisateurs de gérer leurs facteurs d’authentification.

<div id="get-mfa-api-access-tokens">
  ## Obtenir des jetons d’accès à l’API MFA
</div>

Pour envoyer une requête à l’API MFA afin de gérer les inscriptions, vous devez d’abord obtenir un <Tooltip tip="Jeton d’accès : justificatif d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=access+token">jeton d’accès</Tooltip> pour l’API MFA.

Pour utiliser l’API MFA dans le cadre d’un flux d’authentification, vous pouvez suivre les étapes détaillées dans [S’authentifier avec le Resource Owner Password Grant et MFA](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa). Si vous créez une interface utilisateur pour gérer les facteurs d’authentification, vous devrez obtenir un jeton que vous pourrez utiliser avec l’API MFA à tout moment, et pas seulement pendant l’authentification.

Un jeton d’accès MFA, ou un jeton d’accès ayant pour <Tooltip tip="Audience : identifiant unique de l’audience d’un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID d’une application (Client ID) pour un ID Token ou d’une API (API Identifier) pour un jeton d’accès." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=audience">audience</Tooltip> `https://{yourDomain}/mfa/`, sert à la fois à authentifier et à déclencher une [demande de défi](https://auth0.com/docs/api/authentication/muti-factor-authentication/request-mfa-challenge) MFA. L’activation des facteurs dans votre tenant et l’inscription de vos utilisateurs déterminent si le défi MFA est lancé :

* Si votre tenant permet l’inscription à plusieurs facteurs et que vos utilisateurs sont inscrits à un facteur valide (à l’exclusion du courriel), comme un mot de passe à usage unique (OTP), l’utilisateur reçoit le défi MFA à la connexion.
* Si vos utilisateurs ne sont inscrits à aucun facteur d’authentification, ou ne sont inscrits qu’au facteur `email`, le jeton MFA est émis et aucun défi n’est présenté à l’utilisateur.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La durée d’expiration par défaut des jetons d’accès avec l’audience `https://{yourDomain}/mfa/*` est de 10 minutes. Cette valeur ne peut pas être configurée.
</Callout>

<div id="universal-login">
  ### Universal Login
</div>

Si vous utilisez [Universal Login](/docs/fr-ca/authenticate/login/auth0-universal-login), redirigez vers le point de terminaison Authorize en précisant l’`audience` `https://{yourDomain}/mfa/`.

<Warning>
  Lorsque `https://{yourDomain}/mfa/` est précisée comme `audience`, la MFA est exigée. Lorsque des utilisateurs finaux activent **Remember this browser** alors que `.../mfa/` est précisée comme `audience`, ce paramètre n’aura aucun effet.

  Auth0 recommande aux administrateurs de tenant de [créer une action](/docs/fr-ca/customize/actions/write-your-first-action) qui définit `allowRememberBrowser` sur `false`. Cela masquera **Remember this browser** dans l’expérience de l’utilisateur final.
</Warning>

<div id="resource-owner-password-grant">
  ### Octroi par mot de passe du propriétaire de la ressource
</div>

Si vous utilisez le <Tooltip tip="Propriétaire de la ressource : entité (comme un utilisateur ou une application) capable d’accorder l’accès à une ressource protégée." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Resource+Owner">propriétaire de la ressource</Tooltip> Password Grant (ROPG), vous avez 3 options :

* Demandez l’`audience` `https://{yourDomain}/mfa/` à la connexion, puis utilisez un [jeton d’actualisation](/docs/fr-ca/secure/tokens/refresh-tokens) pour l’actualiser plus tard.
* Si vous devez lister et supprimer des authentificateurs, demandez à l’utilisateur de [s’authentifier de nouveau](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa) avec `/oauth/token`, en précisant l’`audience` `https://{yourDomain}/mfa/`. Les utilisateurs devront terminer l’authentification MFA avant de pouvoir lister ou supprimer des facteurs d’authentification.
* Si vous avez seulement besoin de lister des authentificateurs, demandez à l’utilisateur de [s’authentifier de nouveau](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa) à l’aide de `/oauth/token` avec nom d’utilisateur et mot de passe. Le point de terminaison retournera une erreur `mfa_required`, ainsi qu’un `mfa_token` que vous pourrez utiliser pour lister les authentificateurs. Les utilisateurs devront fournir leur mot de passe pour voir leurs authentificateurs.

<div id="scopes">
  ### Portées
</div>

Lorsque vous demandez un jeton pour l’audience MFA, vous pouvez demander les portées suivantes :

| Portée                  | Description                                             |
| ----------------------- | ------------------------------------------------------- |
| `enroll`                | Pour inscrire un nouvel authentificateur.               |
| `read:authenticators`   | Pour afficher la liste des authentificateurs existants. |
| `remove:authenticators` | Pour supprimer un authentificateur.                     |

<div id="list-authenticators">
  ## Lister les authentificateurs
</div>

Pour obtenir la liste des authentificateurs d’un utilisateur, vous pouvez envoyer une requête au point de terminaison MFA Authenticators :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://{yourDomain}/mfa/authenticators' \
    --header 'authorization: Bearer MFA_TOKEN'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/mfa/authenticators");
  var request = new RestRequest(Method.GET);
  request.AddHeader("authorization", "Bearer MFA_TOKEN");
  IRestResponse response = client.Execute(request);
  ```

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

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/mfa/authenticators"

  	req, _ := http.NewRequest("GET", url, nil)

  	req.Header.Add("authorization", "Bearer MFA_TOKEN")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.get("https://{yourDomain}/mfa/authenticators")
    .header("authorization", "Bearer MFA_TOKEN")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'GET',
    url: 'https://{yourDomain}/mfa/authenticators',
    headers: {authorization: 'Bearer MFA_TOKEN'}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/mfa/authenticators",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MFA_TOKEN"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  headers = { 'authorization': "Bearer MFA_TOKEN" }

  conn.request("GET", "/{yourDomain}/mfa/authenticators", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/mfa/authenticators")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Get.new(url)
  request["authorization"] = 'Bearer MFA_TOKEN'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

La réponse devrait contenir des renseignements sur le ou les types d’authentificateurs :

```json lines theme={null}
[
  {
    "authenticator_type": "recovery-code",
    "id": "recovery-code|dev_IsBj5j3H12VAdOIj",
    "active": true
  },
  {
    "authenticator_type": "otp",
    "id": "totp|dev_nELLU4PFUiTW6iWs",
    "active": true,
  },
  {
    "authenticator_type": "oob",
    "oob_channel": "sms",
    "id": "sms|dev_sEe99pcpN0xp0yOO",
    "name": "+1123XXXXX",
    "active": true
  }
]
```

Pour créer une interface utilisateur permettant aux utilisateurs finaux de gérer leurs facteurs, vous devez ignorer les authentificateurs pour lesquels `active` est `false`. Ces authentificateurs n’ont pas été confirmés par les utilisateurs; ils ne peuvent donc pas être utilisés pour la MFA.

L’API MFA répertorie les inscriptions suivantes selon le type d’authentificateur :

| Authentificateur        | Actions                                                                                                                                                                                                                                   |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Push and OTP**        | Si push est activé, Auth0 crée aussi une inscription OTP. Vous verrez les deux lors de l’affichage des inscriptions.                                                                                                                      |
| **SMS and appel vocal** | Si SMS et appel vocal sont tous deux activés, lorsqu’un utilisateur s’inscrit à l’aide de SMS ou d’appel vocal, Auth0 crée automatiquement deux authentificateurs pour le numéro de téléphone : un pour SMS et un autre pour appel vocal. |
| **Email**               | Toutes les adresses courriel vérifiées seront répertoriées comme authentificateurs.                                                                                                                                                       |

<div id="enroll-authenticators">
  ## Inscrire des authentificateurs
</div>

Consultez les liens suivants pour savoir comment inscrire des authentificateurs pour les différents facteurs :

* [SMS ou appel vocal](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-challenge-sms-voice-authenticators)
* [Mot de passe à usage unique (OTP)](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-otp-authenticators)
* [Push](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-push-authenticators)
* [Email](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-email-authenticators)

Vous pouvez aussi utiliser le [flux Universal Login](/docs/fr-ca/secure/multi-factor-authentication/multi-factor-authentication-developer-resources/create-custom-enrollment-tickets) pour y inscrire des utilisateurs en tout temps.

<div id="delete-authenticators">
  ## Supprimer des authentificateurs
</div>

Pour supprimer un authentificateur associé, envoyez une requête `DELETE` au point de terminaison MFA Authenticators en remplaçant `AUTHENTICATOR_ID` par l’ID de l’authentificateur voulu. Vous pouvez obtenir cet ID lorsque vous listez les authentificateurs.

Si un `mfa_token` a été utilisé pour lister les authentificateurs, les utilisateurs devront [effectuer la MFA pour obtenir un jeton d’accès](https://auth0.com/docs/api/authentication/muti-factor-authentication/verify-mfa-with-otp) avec une audience de `https://{yourDomain}/mfa/` afin de supprimer un authentificateur.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request DELETE \
    --url 'https://{yourDomain}/mfa/authenticators/AUTHENTICATOR_ID' \
    --header 'authorization: Bearer ACCESS_TOKEN'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/mfa/authenticators/AUTHENTICATOR_ID");
  var request = new RestRequest(Method.DELETE);
  request.AddHeader("authorization", "Bearer ACCESS_TOKEN");
  IRestResponse response = client.Execute(request);
  ```

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

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/mfa/authenticators/AUTHENTICATOR_ID"

  	req, _ := http.NewRequest("DELETE", url, nil)

  	req.Header.Add("authorization", "Bearer ACCESS_TOKEN")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.delete("https://{yourDomain}/mfa/authenticators/AUTHENTICATOR_ID")
    .header("authorization", "Bearer ACCESS_TOKEN")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'DELETE',
    url: 'https://{yourDomain}/mfa/authenticators/AUTHENTICATOR_ID',
    headers: {authorization: 'Bearer ACCESS_TOKEN'}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/mfa/authenticators/AUTHENTICATOR_ID",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "DELETE",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer ACCESS_TOKEN"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  headers = { 'authorization': "Bearer ACCESS_TOKEN" }

  conn.request("DELETE", "/{yourDomain}/mfa/authenticators/AUTHENTICATOR_ID", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/mfa/authenticators/AUTHENTICATOR_ID")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Delete.new(url)
  request["authorization"] = 'Bearer ACCESS_TOKEN'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Si l’authentificateur a été supprimé, une réponse 204 est renvoyée.

Lorsque vous supprimez un authentificateur, les actions suivantes se produisent selon le type d’authentificateur :

| Authentificateur        | Action                                                                                                                                                                                                         |
| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Push and OTP**        | Lorsqu’un utilisateur inscrit un authentificateur push, Auth0 inscrit aussi OTP. Si vous en supprimez un, l’autre sera également supprimé.                                                                     |
| **SMS and appel vocal** | Lorsqu’un utilisateur s’inscrit à SMS ou à appel vocal, Auth0 crée deux authentificateurs, SMS et appel vocal. Si vous en supprimez un, l’autre sera également supprimé.                                       |
| **Email**               | Toutes les adresses courriel vérifiées sont listées comme authentificateurs, mais vous ne pouvez pas les supprimer. Vous pouvez uniquement supprimer les authentificateurs de courriel explicitement inscrits. |

<div id="regenerate-recovery-codes">
  ## Régénérer les codes de récupération
</div>

Pour supprimer un code de récupération et en générer un nouveau, obtenez un [jeton d’accès à l’API de gestion](https://auth0.com/docs/api/management/v2/tokens) Auth0, puis utilisez le <Tooltip tip="API de gestion : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">API de gestion</Tooltip> [point de terminaison de régénération du code de récupération](https://auth0.com/docs/api/management/v2/#!/Users/post_recovery_code_regeneration).

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/users/USER_ID/recovery-code-regeneration' \
    --header 'authorization: Bearer MANAGEMENT_API_TOKEN'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/users/USER_ID/recovery-code-regeneration");
  var request = new RestRequest(Method.POST);
  request.AddHeader("authorization", "Bearer MANAGEMENT_API_TOKEN");
  IRestResponse response = client.Execute(request);
  ```

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

  import (
  	"fmt"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/users/USER_ID/recovery-code-regeneration"

  	req, _ := http.NewRequest("POST", url, nil)

  	req.Header.Add("authorization", "Bearer MANAGEMENT_API_TOKEN")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.post("https://{yourDomain}/api/v2/users/USER_ID/recovery-code-regeneration")
    .header("authorization", "Bearer MANAGEMENT_API_TOKEN")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/users/USER_ID/recovery-code-regeneration',
    headers: {authorization: 'Bearer MANAGEMENT_API_TOKEN'}
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/users/USER_ID/recovery-code-regeneration",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MANAGEMENT_API_TOKEN"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  headers = { 'authorization': "Bearer MANAGEMENT_API_TOKEN" }

  conn.request("POST", "/{yourDomain}/api/v2/users/USER_ID/recovery-code-regeneration", headers=headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/users/USER_ID/recovery-code-regeneration")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["authorization"] = 'Bearer MANAGEMENT_API_TOKEN'

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Vous obtiendrez un nouveau code de récupération que l’utilisateur final devra conserver, par exemple :

```json lines theme={null}
{  
   "recovery_code": "FA45S1Z87MYARX9RG6EVMAPE"
}
```

<div id="learn-more">
  ## En savoir plus
</div>

* [Inscrire et vérifier les authentificateurs SMS et vocaux](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-challenge-sms-voice-authenticators)
* [Inscrire et vérifier les authentificateurs OTP](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-otp-authenticators)
* [Inscrire et vérifier les authentificateurs push](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-push-authenticators)
* [Inscrire et vérifier les authentificateurs par courriel](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-email-authenticators)
* [Vérifier avec des codes de récupération](/docs/fr-ca/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/challenge-with-recovery-codes)