> ## 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.

> Describe cómo administrar las inscripciones de factores de autenticación MFA para aplicaciones que usan la API de MFA de Auth0.

# Administrar factores de autenticación con 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) + "*****ENMASCARADO*****";
          }
          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="Antes de empezar">
  * Habilita el tipo de concesión **MFA** para tu aplicación. Para obtener más información, consulta [Actualizar tipos de concesión](/es/docs/get-started/applications/update-grant-types).
</Card>

Auth0 proporciona varios [endpoints de API](https://auth0.com/docs/api/authentication#multi-factor-authentication) para ayudarte a administrar los autenticadores que utilizas con una aplicación para la <Tooltip tip="Autenticación multifactor (MFA): proceso de autenticación de usuarios que usa un factor además del nombre de usuario y la contraseña, como un código por SMS." cta="Ver glosario" href="/es/docs/glossary?term=multi-factor+authentication">autenticación multifactor</Tooltip> (MFA). Puedes usar estos endpoints para crear una interfaz de usuario completa que permita a los usuarios administrar sus factores de autenticación.

<div id="get-mfa-api-access-tokens">
  ## Obtener tokens de acceso para la API de MFA
</div>

Para llamar a la API de MFA y administrar las inscripciones, primero debe obtener un <Tooltip tip="Token de acceso: credencial de autorización, en forma de cadena opaca o JWT, que se utiliza para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=access+token">token de acceso</Tooltip> para la API de MFA.

Para usar la API de MFA como parte de un flujo de autenticación, puede seguir los pasos detallados en [Autenticarse con Resource Owner Password Grant y MFA](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa). Si está creando una interfaz de usuario para administrar factores de autenticación, deberá obtener un token que pueda usar con la API de MFA en cualquier momento, no solo durante la autenticación.

Un token de acceso de MFA, o un token de acceso con la <Tooltip tip="Audiencia: identificador único de la audiencia de un token emitido. Se denomina aud en un token y su valor contiene el ID de una aplicación (ID de cliente) para un ID Token o de una API (identificador de API) para un Token de acceso." cta="Ver glosario" href="/es/docs/glossary?term=audience">audiencia</Tooltip> `https://{yourDomain}/mfa/`, autentica simultáneamente y desencadena una [solicitud de desafío](https://auth0.com/docs/api/authentication/muti-factor-authentication/request-mfa-challenge) de MFA. La habilitación de factores en su inquilino y la inscripción de sus usuarios determinan si se inicia el desafío de MFA:

* Si su inquilino permite la inscripción en varios factores y sus usuarios se inscriben en un factor válido (excepto correo electrónico), como una contraseña de un solo uso (OTP), el usuario recibe el desafío de MFA al iniciar sesión.
* Si sus usuarios no están inscritos en ningún factor de autenticación, o solo están inscritos en el factor `email`, se genera el token de MFA y no se emite ningún desafío para el usuario.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  El tiempo de expiración predeterminado de los tokens de acceso con la audiencia `https://{yourDomain}/mfa/*` es de 10 minutos. Este valor no se puede configurar.
</Callout>

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

Si utiliza [Universal Login](/es/docs/authenticate/login/auth0-universal-login), redirija al endpoint Authorize y especifique la audiencia `https://{yourDomain}/mfa/`.

<Warning>
  Cuando se especifica `https://{yourDomain}/mfa/` como audiencia, MFA se aplica de forma obligatoria. Si los usuarios finales habilitan **Remember this browser** mientras `.../mfa/` se especifica como audiencia, la configuración no tendrá efecto.

  Auth0 recomienda que los administradores del inquilino [creen una Action](/es/docs/customize/actions/write-your-first-action) que establezca `allowRememberBrowser` en false. Esto ocultará **Remember this browser** en la experiencia del usuario final.
</Warning>

<div id="resource-owner-password-grant">
  ### Grant de contraseña del propietario del recurso
</div>

Si está utilizando el <Tooltip tip="Propietario del recurso: entidad (como un usuario o una aplicación) capaz de conceder acceso a un recurso protegido." cta="Ver glosario" href="/es/docs/glossary?term=Resource+Owner">Propietario del recurso</Tooltip> Password Grant (ROPG), tiene 3 opciones:

* Solicite la audiencia `https://{yourDomain}/mfa/` al iniciar sesión y use un [Token de actualización](/es/docs/secure/tokens/refresh-tokens) para renovarlo más adelante.
* Si necesita listar y eliminar autenticadores, pida al usuario que [se autentique de nuevo](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa) con `/oauth/token`, especificando la audiencia `https://{yourDomain}/mfa/`. Los usuarios deberán completar MFA antes de poder listar o eliminar factores de autenticación.
* Si solo necesita listar autenticadores, pida al usuario que [se autentique de nuevo](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa) usando `/oauth/token` con username y contraseña. El endpoint devolverá un error `mfa_required` y un `mfa_token` que puede usar para listar autenticadores. Los usuarios deberán proporcionar su contraseña para ver sus autenticadores.

<div id="scopes">
  ### Alcances
</div>

Cuando solicitas un token para la audiencia de MFA, puedes solicitar los siguientes alcances:

| Alcance                 | Descripción                                |
| ----------------------- | ------------------------------------------ |
| `enroll`                | Para inscribir un nuevo autenticador.      |
| `read:authenticators`   | Para listar los autenticadores existentes. |
| `remove:authenticators` | Para eliminar un autenticador.             |

<div id="list-authenticators">
  ## Listar autenticadores
</div>

Para obtener una lista de los autenticadores de un usuario, puedes llamar al endpoint de autenticadores de MFA:

<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_NONE

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

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

Deberías recibir en la respuesta información sobre el tipo o los tipos de autenticador:

```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
  }
]
```

Para crear una interfaz de usuario para que los usuarios finales administren sus factores, debe ignorar los autenticadores cuyo valor de `active` sea `false`. Esos autenticadores no han sido confirmados por los usuarios, por lo que no pueden usarse en desafíos de MFA.

La API de MFA mostrará las siguientes inscripciones según el tipo de autenticador:

| Autenticador           | Acciones                                                                                                                                                                                      |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Push y OTP**         | Si push está habilitado, Auth0 también crea una inscripción de OTP. Verá ambas al listar las inscripciones.                                                                                   |
| **SMS y voz**          | Si tanto SMS como voz están habilitados, cuando un usuario se inscribe con SMS o voz, Auth0 crea automáticamente dos autenticadores para el número de teléfono: uno para SMS y otro para voz. |
| **Correo electrónico** | Todos los correos electrónicos verificados aparecerán en la lista como autenticadores.                                                                                                        |

<div id="enroll-authenticators">
  ## Inscribir autenticadores
</div>

Consulte los siguientes enlaces para obtener más información sobre cómo inscribir autenticadores para distintos factores:

* [SMS o voz](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-challenge-sms-voice-authenticators)
* [Contraseña de un solo uso (OTP)](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-otp-authenticators)
* [Push](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-push-authenticators)
* [Correo electrónico](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-email-authenticators)

También puede usar el [flujo de Universal Login](/es/docs/secure/multi-factor-authentication/multi-factor-authentication-developer-resources/create-custom-enrollment-tickets) para inscribir a los usuarios en cualquier momento.

<div id="delete-authenticators">
  ## Eliminar autenticadores
</div>

Para eliminar un autenticador asociado, envía una solicitud `DELETE` al endpoint de autenticadores de MFA y reemplaza `AUTHENTICATOR_ID` por el ID del autenticador correspondiente. Puedes obtener el ID al listar los autenticadores.

Si se usó un `mfa_token` para listar autenticadores, los usuarios deberán [completar MFA para obtener un token de acceso](https://auth0.com/docs/api/authentication/muti-factor-authentication/verify-mfa-with-otp) con una audiencia de `https://{yourDomain}/mfa/` para poder eliminar un autenticador.

<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_NONE

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

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

Si se eliminó el autenticador, se devuelve una respuesta 204.

Cuando eliminas un autenticador, se realizan las siguientes acciones según el tipo de autenticador:

| Autenticador           | Acción                                                                                                                                                                                       |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Push y OTP**         | Cuando un usuario inscribe un autenticador push, Auth0 también inscribe OTP. Si eliminas cualquiera de los dos, el otro también se eliminará.                                                |
| **SMS y Voz**          | Cuando un usuario se inscribe en SMS o Voz, Auth0 crea dos autenticadores: SMS y voz. Si eliminas cualquiera de los dos, el otro también se eliminará.                                       |
| **Correo electrónico** | Todos los correos electrónicos verificados aparecen como autenticadores, pero no puedes eliminarlos. Solo puedes eliminar los autenticadores de correo electrónico inscritos explícitamente. |

<div id="regenerate-recovery-codes">
  ## Regenerar códigos de recuperación
</div>

Para eliminar un código de recuperación y generar uno nuevo, obtén un [token de acceso para la Management API](https://auth0.com/docs/api/management/v2/tokens) de Auth0 y usa el <Tooltip tip="Management API: Un producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Management+API">Management API</Tooltip> [endpoint de regeneración del código de recuperación](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_NONE

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

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

Recibirás un nuevo código de recuperación que el usuario final deberá guardar; por ejemplo:

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

<div id="learn-more">
  ## Más información
</div>

* [Inscribirse y usar autenticadores SMS y de voz](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-challenge-sms-voice-authenticators)
* [Inscribirse y usar autenticadores OTP](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-otp-authenticators)
* [Inscribirse y usar autenticadores push](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-push-authenticators)
* [Inscribirse y usar autenticadores de correo electrónico](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-and-challenge-email-authenticators)
* [Autenticarse con códigos de recuperación](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/challenge-with-recovery-codes)