> ## 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 los idiomas que puedes elegir para localizar tus páginas de Login.

# Internacionalización de Universal Login

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

<div id="universal-login-localization">
  ## Localización de Universal Login
</div>

La experiencia de <Tooltip tip="Universal Login: Su 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> está disponible en los siguientes idiomas. Las entradas marcadas con un asterisco se leen de derecha a izquierda.

| Idioma                   | Código   |
| ------------------------ | -------- |
| Albanés                  | `sq`     |
| Amárico                  | `am`     |
| Árabe\*                  | `ar`     |
| Árabe (Egipto)\*         | `ar-EG`  |
| Árabe (Arabia Saudita)\* | `ar-SA`  |
| Armenio                  | `hy`     |
| Azerbaiyano              | `az`     |
| Vasco                    | `eu-ES`  |
| Bengalí                  | `bn`     |
| Bosnio                   | `bs`     |
| Búlgaro                  | `bg`     |
| Catalán                  | `ca-ES`  |
| Chino - Hong Kong        | `zh-HK`  |
| Chino - Simplificado     | `zh-CN`  |
| Chino - Tradicional      | `zh-TW`  |
| Croata                   | `hr`     |
| Checo                    | `cs`     |
| Danés                    | `da`     |
| Neerlandés               | `nl`     |
| Inglés                   | `en`     |
| Inglés - Canadá          | `en-CA`  |
| Estonio                  | `et`     |
| Farsi (persa)\*          | `fa`     |
| Finés                    | `fi`     |
| Francés                  | `fr-FR`  |
| Francés - Canadá         | `fr-CA`  |
| Gallego                  | `gl-ES`  |
| Georgiano                | `ka`     |
| Alemán                   | `de`     |
| Griego                   | `el`     |
| Guyaratí                 | `gu`     |
| Hebreo\*                 | `he`     |
| Hindi                    | `hi`     |
| Húngaro                  | `hu`     |
| Islandés                 | `is`     |
| Indonesio                | `id`     |
| Italiano                 | `it`     |
| Japonés                  | `ja`     |
| Canarés                  | `kn`     |
| Coreano                  | `ko`     |
| Letón                    | `lv`     |
| Lituano                  | `lt`     |
| Macedonio                | `mk`     |
| Malayo                   | `ms`     |
| Malayalam                | `ml`     |
| Maratí                   | `mr`     |
| Mongol                   | `mn`     |
| Montenegrino             | `cnr`    |
| Birmano                  | `my`     |
| Noruego                  | `no`     |
| Noruego - Bokmål         | `nb`     |
| Noruego - Nynorsk        | `nn`     |
| Polaco                   | `pl`     |
| Portugués - Brasil       | `pt-BR`  |
| Portugués - Portugal     | `pt-PT`  |
| Panyabí                  | `pa`     |
| Rumano                   | `ro`     |
| Ruso                     | `ru`     |
| Serbio                   | `sr`     |
| Eslovaco                 | `sk`     |
| Esloveno                 | `sl`     |
| Somalí                   | `so`     |
| Español                  | `es`     |
| Español - Argentina      | `es-AR`  |
| Español - América Latina | `es-419` |
| Español - México         | `es-MX`  |
| Suajili                  | `sw`     |
| Sueco                    | `sv`     |
| Tagalo                   | `tl`     |
| Tamazight                | `zgh`    |
| Tamil                    | `ta`     |
| Telugu                   | `te`     |
| Tailandés                | `th`     |
| Turco                    | `tr`     |
| Ucraniano                | `uk`     |
| Urdu\*                   | `ur`     |
| Vietnamita               | `vi`     |
| Galés                    | `cy`     |

<div id="language-selection">
  ### Selección de idioma
</div>

Auth0 selecciona el idioma en que se muestran las páginas en función de lo siguiente:

* Los idiomas compatibles con Auth0, que se enumeran arriba.
* La lista de idiomas configurados en la sección [**Tenant Settings**](https://manage.auth0.com/#/tenant) del Auth0 Dashboard, donde puede seleccionar los idiomas que admite su inquilino y elegir uno predeterminado. De forma predeterminada, en la lista solo está seleccionado el inglés, pero puede seleccionar los que necesite.
* El valor del parámetro `ui_locales` enviado al [endpoint de solicitud de autorización](https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest), que puede usarse para restringir la lista de idiomas de una aplicación o sesión. Puede proporcionar una lista de configuraciones regionales separadas por espacios. La primera configuración regional de la lista debe coincidir con una configuración regional habilitada en su inquilino para que se refleje en la UI.
* El encabezado HTTP `Accept-Language` enviado por el navegador. Auth0 muestra las páginas en este idioma si está permitido por la configuración anterior. De lo contrario, las páginas se muestran en el idioma predeterminado.

Use 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> de Auth0 para hacer una llamada `PATCH` al [endpoint Tenants](https://auth0.com/docs/api/management/v2/tenants/patch-settings) con el siguiente cuerpo, reemplazando `he` por el código de idioma que desea agregar:

```json lines theme={null}
{
  "enabled_locales": [
    "en","he"
  ]
}
```

Después de añadirlo, especifique el idioma en el parámetro de consulta`ui_locales` de la solicitud de Login.

También puede especificar los idiomas habilitados para el inquilino a través de la Management API mediante el [endpoint Update Tenants](https://auth0.com/docs/api/management/v2#!/Tenants/patch_settings). El idioma predeterminado es el primero de la lista.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/tenants/settings' \
    --header 'authorization: Bearer API2_ACCESS_TOKEN' \
    --header 'content-type: application/json' \
    --data '{ "enabled_locales" : [ "en", "es"]}'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/tenants/settings");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer API2_ACCESS_TOKEN");
  request.AddParameter("application/json", "{ "enabled_locales" : [ "en", "es"]}", 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/tenants/settings"

  	payload := strings.NewReader("{ "enabled_locales" : [ "en", "es"]}")

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

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer API2_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.patch("https://{yourDomain}/api/v2/tenants/settings")
    .header("content-type", "application/json")
    .header("authorization", "Bearer API2_ACCESS_TOKEN")
    .body("{ "enabled_locales" : [ "en", "es"]}")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/tenants/settings',
    headers: {'content-type': 'application/json', authorization: 'Bearer API2_ACCESS_TOKEN'},
    data: {enabled_locales: ['en', 'es']}
  };

  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/tenants/settings",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PATCH",
    CURLOPT_POSTFIELDS => "{ "enabled_locales" : [ "en", "es"]}",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer API2_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 = "{ "enabled_locales" : [ "en", "es"]}"

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

  conn.request("PATCH", "/{yourDomain}/api/v2/tenants/settings", 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/tenants/settings")

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

  request = Net::HTTP::Patch.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer API2_ACCESS_TOKEN'
  request.body = "{ "enabled_locales" : [ "en", "es"]}"

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

<div id="right-to-left-languages">
  ### Idiomas de derecha a izquierda
</div>

<Warning>
  La compatibilidad con idiomas de derecha a izquierda está disponible en Acceso anticipado. Para solicitar esta función, [contacte con el equipo de soporte de Auth0](https://support.auth0.com/).  Al usar esta función, acepta los términos aplicables de la prueba gratuita incluidos en el [Master Subscription Agreement](https://www.okta.com/legal/) de Okta. Para obtener más información sobre el ciclo de lanzamiento de productos de Auth0, consulte [Etapas de lanzamiento del producto](/es/docs/troubleshoot/product-lifecycle/product-release-stages).
</Warning>

La compatibilidad con idiomas de derecha a izquierda (RtL) permite que su inquilino muestre texto en árabe (estándar, egipcio y saudí), persa, hebreo y urdu. Los inquilinos que usan texto RtL deben cumplir con [WCAG 2.2 AA](/es/docs/authenticate/login/auth0-universal-login#accessibility) y, si su inquilino usa plantillas de página, debe actualizar la etiqueta HTML para incluir `dir`.

```liquid lines theme={null}
{% assign resolved_dir = dir | default: "auto" %}
<html lang="{{locale}}" dir="{{resolved_dir}}">
```

<div id="limitations">
  ### Limitaciones
</div>

* El parámetro `ui_locales` solo se puede usar en flujos de <Tooltip tip="OAuth 2.0: Marco de autorización que define protocolos y flujos de trabajo de autorización." cta="Ver glosario" href="/es/docs/glossary?term=OAuth">OAuth</Tooltip>, ya que no está disponible con Lenguaje de marcado para aserciones de seguridad <Tooltip tip="OAuth 2.0: Marco de autorización que define protocolos y flujos de trabajo de autorización." cta="Ver glosario" href="/es/docs/glossary?term=SAML">(SAML)</Tooltip> ni con WS-Federation.
* El parámetro `ui_locales` no se reenvía a los proveedores de identidad (IdP) externos <Tooltip tip="Proveedor de identidad (IdP): Servicio que almacena y administra identidades digitales." cta="Ver glosario" href="/es/docs/glossary?term=IdPs">IdPs</Tooltip>. Para obtener más información sobre cómo pasar parámetros a los IdP, consulta [Pasar parámetros a proveedores de identidad](/es/docs/authenticate/identity-providers/pass-parameters-to-idps).
* No es posible localizar los alcances en la página Consent.

<div id="known-issues">
  ### Problemas conocidos
</div>

* La página de Universal Login muestra el atributo HTML `lang` para el código de idioma `fr-FR` como `fr`.
* La página de Universal Login muestra el atributo HTML `lang` para el código de idioma `pt-PT` como `pt`.

<div id="classic-login-localization">
  ## Localización de Classic Login
</div>

En la experiencia de Classic Login, la localización usa los widgets de JavaScript de Auth0 para [Login](/es/docs/customize/internationalization-and-localization/lock-internationalization), la [página de restablecimiento de contraseña](/es/docs/customize/login-pages/classic-login/customize-password-reset-page) y las [políticas de contraseñas](/es/docs/customize/internationalization-and-localization/password-options-translation).

La [página de autenticación multifactor (MFA)](/es/docs/secure/multi-factor-authentication/customize-mfa/customize-mfa-classic-login) usa, de forma predeterminada, el widget de <Tooltip tip="Autenticación multifactor (MFA): Proceso de autenticación que utiliza un factor adicional además de username y contraseña, como un code enviado por SMS." cta="Ver glosario" href="/es/docs/glossary?term=MFA">MFA</Tooltip> de Auth0, que no se puede localizar. Puede crear versiones localizadas con [guardian.js](https://github.com/auth0/auth0-guardian.js).

No se puede localizar la página de [Consent](/es/docs/customize/login-pages/customize-consent-prompts).

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

* [Personaliza las plantillas de página de Universal Login](/es/docs/customize/login-pages/universal-login/customize-templates)
* [Personaliza las páginas de Classic Login con Lock o el SDK](/es/docs/customize/login-pages/classic-login/customize-with-lock-sdk)