> ## 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 configurar las notificaciones por SMS y voz para MFA.

# Configuración de notificaciones por SMS y voz para MFA

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

<Warning>
  Unified Phone Experience centraliza toda la configuración de tus proveedores telefónicos en un único lugar de tu inquilino, por lo que no necesitas configurar el mismo proveedor telefónico varias veces para distintos factores de autenticación por teléfono. Para obtener más información, consulta [Usa Unified Phone Experience de Auth0 para la autenticación multifactor](/es/docs/customize/phone-messages/unified-phone/use-auth0s-unified-phone-experience-for-multi-factor-authentication).
</Warning>

Si usas SMS o voz como factores de autenticación, cuando un usuario final intenta autenticarse en tu aplicación, se le envía un code por SMS o voz, que deberá introducir para completar la transacción. Esto implica que conoce sus credenciales de inicio de sesión y que tiene en su poder el dispositivo que registró para usar <Tooltip tip="Autenticación multifactor (MFA): proceso de autenticación de usuarios que utiliza un factor adicional al username y la contraseña, como un code enviado por SMS." cta="Ver glosario" href="/es/docs/glossary?term=MFA">MFA</Tooltip>.

Puedes configurar los factores SMS y voz mediante el Dashboard o la <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> para enviar mensajes por SMS, por voz o para permitir que los usuarios finales elijan cómo quieren recibir el code. Puedes configurar tu proveedor de envío mediante Actions, configurar tu cuenta de Twilio o, si solo quieres enviar SMS a los clientes, configurar el servicio de envío de mensajes predeterminado de Auth0. Debes usar la experiencia de <Tooltip tip="Universal Login: tu aplicación redirige a Universal Login, alojado en el Servidor de autorización de Auth0, para verificar la identidad de un usuario." cta="Ver glosario" href="/es/docs/glossary?term=Universal+Login">Universal Login</Tooltip> para habilitar las notificaciones de voz para MFA.

<Card title="La disponibilidad varía según el plan de Auth0">
  Tanto tu implementación específica de inicio de sesión como tu plan de Auth0 o acuerdo personalizado determinan si esta función está disponible. Para obtener más información, consulta [Precios](https://auth0.com/pricing).
</Card>

<div id="how-it-works">
  ## Cómo funciona
</div>

Cuando SMS y Voice están habilitados, los usuarios pueden inscribirse recibiendo el code por SMS o por voz:

<Frame>
  <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2Q4BViGl71sdrytUDgNJ10/693969bb00444c6bef030e90bb1015f2/2025-02-12_10-06-29.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=963199a983adf4d185cbace53b287c34" alt="Configurar SMS y Voice para la experiencia de usuario de MFA con Voice" width="901" height="834" data-path="docs/images/cdy7uua7fh8z/2Q4BViGl71sdrytUDgNJ10/693969bb00444c6bef030e90bb1015f2/2025-02-12_10-06-29.png" />
</Frame>

Cuando solo habilita SMS, el flujo es más simple:

<Frame>
  <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/64PgR0CO1Wjfie2Hxy1Ptw/e6dcf80c0739f8235b473c0291a01e63/2025-02-12_10-07-15.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=5681ef6de8dc55385d33d3ffc661f7c9" alt="Configurar SMS y Voice para la experiencia de usuario de MFA con SMS" width="899" height="312" data-path="docs/images/cdy7uua7fh8z/64PgR0CO1Wjfie2Hxy1Ptw/e6dcf80c0739f8235b473c0291a01e63/2025-02-12_10-07-15.png" />
</Frame>

Después de que los usuarios se hayan inscrito, la próxima vez que se autentiquen recibirán el mensaje de voz o SMS en su teléfono registrado.

<div id="use-the-dashboard">
  ## Usa el Dashboard
</div>

1. Ve a [Dashboard > Security > Multi-factor Auth](https://manage.auth0.com/#/multifactor-auth).
2. Haz clic en **Phone Message** y habilita el interruptor en la parte superior.
3. Selecciona el proveedor de envío de mensajes que prefieras.
4. Para permitir que los usuarios se autentiquen con SMS y voz, debes habilitar los factores SMS y voz, y seleccionar el método de entrega que prefieras:

   1. **Auth0**: No puedes usar este proveedor para enviar mensajes de voz. Envía mensajes SMS mediante el proveedor de entrega de SMS configurado internamente por Auth0. Solo puede usarse con fines de evaluación y prueba, y hay un máximo de 100 mensajes por inquilino durante toda la vida del inquilino. No se recibirán nuevos códigos una vez alcanzado el límite de 100 mensajes.
   2. **Twilio**: Envía los mensajes mediante la [Twilio Programmable SMS API](https://www.twilio.com/sms) para SMS o la [Twilio Programmable Voice API](https://www.twilio.com/voice) para voz. Usa las credenciales Live de Twilio, no las credenciales de prueba, que solo están pensadas para enviar mensajes en un entorno de producción.
   3. **Custom**: Envía los mensajes invocando una Action en el [flujo Send Phone Message](/es/docs/customize/actions/explore-triggers/mfa-notifications-trigger).

   También puedes ofrecer a los usuarios la opción de recibir mensajes de texto SMS, llamadas de voz o ambos.

<div id="twilio-configuration">
  ### Configuración de Twilio
</div>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Tenga en cuenta que Twilio puede tardar hasta ocho (8) semanas en portar y verificar transferencias masivas. Para obtener más información, visite el [Centro de ayuda de Twilio](https://help.twilio.com/articles/223179468-How-long-does-it-take-to-port-a-number-to-Twilio).
</Callout>

Si elige enviar SMS mediante Twilio, siga estos pasos para configurar su factor de SMS.

1. Cree una cuenta con Twilio. Necesitará un [Twilio Account SID](https://www.twilio.com/help/faq/twilio-basics/what-is-an-application-sid) y un [Twilio Auth Token](https://www.twilio.com/help/faq/twilio-basics/what-is-the-auth-token-and-how-can-i-change-it). Estas son las credenciales de la API de Twilio que Auth0 usará para enviar un SMS al usuario.
2. Es posible que también deba habilitar permisos para SMS o voz en su región geográfica: [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) o [voz](https://www.twilio.com/console/voice/calls/geo-permissions). Si usa voz, su cuenta debe tener habilitado un número de teléfono de Twilio para realizar llamadas de voz. Puede ser un número de teléfono externo [verificado con Twilio](https://support.twilio.com/hc/en-us/articles/223180048-Adding-a-Verified-Phone-Number-or-Caller-ID-with-Twilio), o bien puede comprar y configurar un número de teléfono de Twilio desde su cuenta.
3. Configure la conexión. Vaya a [Dashboard > Security - Multi-factor Auth](https://manage.auth0.com/#/security/mfa) y elija **Phone Message**.
4. En **Choose your delivery provider**, elija **Twilio** y seleccione un método de entrega.
5. Introduzca su **Twilio Account SID** y **Twilio Auth Token** en los campos correspondientes.
6. Elija su **SMS Source**.

   1. Si elige **Use From**, deberá introducir el número de teléfono de **From** que los usuarios verán como remitente del SMS. También puede configurarlo en Twilio.
   2. Si elige **Use Messaging Services**, deberá introducir un [Messaging Service SID](https://www.twilio.com/docs/sms/services/services-send-messages).
   3. Si usa voz, siempre debe configurar **From**, incluso si usa **Message Services** para SMS. Asegúrese de que el número de teléfono esté configurado para enviar mensajes SMS y de voz.
7. Haga clic en **Save**.

<div id="customize-sms-or-voice-message-templates">
  ### Personalice las plantillas de mensajes SMS o de voz
</div>

Puede personalizar sus plantillas de mensajes SMS y de voz. Para obtener más información, consulte [Personalice los mensajes SMS y de voz](/es/docs/customize/customize-sms-or-voice-messages).

<div id="use-the-management-api">
  ## Usa la Management API
</div>

Puedes usar la Management API para configurar qué métodos de entrega de mensajes están habilitados mediante el endpoint `/api/v2/guardian/factors/phone/message-types`. El parámetro `message_types` es una matriz que puede ser `["sms"]`, `["voice"]` o `["sms", "voice"]`. Necesitas un [token de acceso para la Management API](/es/docs/secure/tokens/access-tokens/management-api-access-tokens) con el scope `update:guardian_factors` como Bearer Token para llamar a la API:

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PUT \
    --url 'https://{yourDomain}/api/v2/guardian/factors/phone/message-types' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'content-type: application/json' \
    --data '{ "message_types": ["sms", "voice"] }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/guardian/factors/phone/message-types");
  var request = new RestRequest(Method.PUT);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddParameter("application/json", "{ "message_types": ["sms", "voice"] }", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://{yourDomain}/api/v2/guardian/factors/phone/message-types"

  	payload := strings.NewReader("{ "message_types": ["sms", "voice"] }")

  	req, _ := http.NewRequest("PUT", url, payload)

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer MGMT_API_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.put("https://{yourDomain}/api/v2/guardian/factors/phone/message-types")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .body("{ "message_types": ["sms", "voice"] }")
    .asString();
  ```

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

  var options = {
    method: 'PUT',
    url: 'https://{yourDomain}/api/v2/guardian/factors/phone/message-types',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN'
    },
    data: {message_types: ['sms', 'voice']}
  };

  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/guardian/factors/phone/message-types",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_POSTFIELDS => "{ "message_types": ["sms", "voice"] }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "content-type: application/json"
    ],
  ]);

  $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("")

  payload = "{ "message_types": ["sms", "voice"] }"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN"
      }

  conn.request("PUT", "/{yourDomain}/api/v2/guardian/factors/phone/message-types", payload, 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/guardian/factors/phone/message-types")

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

  request = Net::HTTP::Put.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request.body = "{ "message_types": ["sms", "voice"] }"

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

<div id="integrated-sms-messaging-providers">
  ## Proveedores integrados de mensajería SMS
</div>

Auth0 admite de forma predeterminada el envío de mensajes a través de Twilio. Sin embargo, puede usar un proveedor de SMS distinto y agregar lógica específica antes de enviar un mensaje, o enviar un mensaje diferente según el usuario o la aplicación. Para ello, configure MFA por SMS para usar una de nuestras [Actions](/es/docs/customize/actions) integradas en el [flujo Send Phone Message](/es/docs/customize/actions/explore-triggers/mfa-notifications-trigger).

Los proveedores integrados de mensajería SMS incluyen:

* [Amazon SNS](https://marketplace.auth0.com/integrations/amazon-sms-provider)
* [ClickSend](https://marketplace.auth0.com/integrations/clicksend-sms)
* [Esendex](https://marketplace.auth0.com/integrations/esendex-sms-provider)
* [Infobip](https://marketplace.auth0.com/integrations/infobip-sms-provider)
* [Mitto](https://marketplace.auth0.com/integrations/mitto-sms-provider)
* [Telesign](https://marketplace.auth0.com/integrations/telesign-sms-verification)

<div id="custom-phone-providers">
  ## Proveedores telefónicos personalizados
</div>

También puede configurar proveedores telefónicos personalizados con Actions. Para obtener más información, consulte [Configurar un proveedor telefónico personalizado](/es/docs/customize/phone-messages/configure-phone-messaging-providers/configure-a-custom-phone-provider).

<div id="security-considerations">
  ## Consideraciones de seguridad
</div>

Al usar cualquier proveedor de mensajería telefónica, tenga en cuenta que los atacantes que abusen del flujo de registro podrían causarle pérdidas económicas.

Auth0 permite que un mismo usuario envíe hasta 10 mensajes SMS o de voz por hora, y los flujos de OTP por correo electrónico o autenticadores están limitados a cinco solicitudes cada cinco minutos. (El límite de ráfaga es 10, pero solo se enviará 1 mensaje de voz por hora para nuevas solicitudes). Para proteger aún más su cuenta, considere lo siguiente:

* Habilite [Suspicious IP Throttling](/es/docs/secure/attack-protection/suspicious-ip-throttling#signup-attempts). Auth0 bloqueará una IP si intenta realizar más de 50 solicitudes de registro por minuto.
* Habilite [Log Streaming](/es/docs/customize/log-streams) y cree alertas con su herramienta de monitoreo preferida cuando vea picos en la cantidad de `gd_send_voice`, `gd_send_voice_failure`, `gd_send_sms` o `gd_send_sms_failure` [eventos de registro](/es/docs/deploy-monitor/logs/log-event-type-codes).

Los proveedores de mensajería telefónica tienen protecciones adicionales. Si usa Twilio, lea la [guía para desarrolladores sobre prevención de fraude de Twilio](https://www.twilio.com/docs/usage/anti-fraud-developer-guide). Considere las siguientes opciones:

* Limite los países a los que enviará mensajes de [SMS](https://support.twilio.com/hc/en-us/articles/223181108-How-International-SMS-Permissions-work) y [voz](https://support.twilio.com/hc/en-us/articles/223180228-International-Voice-Dialing-Geographic-Permissions-Geo-Permissions-and-How-They-Work). Esto es especialmente útil si hay países con mayor riesgo de [fraude telefónico](https://www.twilio.com/learn/voice-and-video/toll-fraud) o con tarifas de llamadas más altas con los que normalmente no opera.
* Habilite los [desencadenadores de uso](https://support.twilio.com/hc/en-us/articles/223132387-Protect-your-Twilio-project-from-Fraud-with-Usage-Triggers) de Twilio para proteger su cuenta contra el fraude y los errores de código.

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

* [Inscripción y desafío de autenticadores SMS y de voz](/es/docs/secure/multi-factor-authentication/authenticate-using-ropg-flow-with-mfa/enroll-challenge-sms-voice-authenticators)
* [Protección contra ataques](/es/docs/secure/attack-protection)
* [Transmisión de registros](/es/docs/customize/log-streams)