> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-fix-docs-5525.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Internationalisation de la connexion universelle

> Cette section décrit les langues que vous pouvez choisir pour localiser vos pages de connexion.

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) + "*****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>;
};

## Localisation de la connexion universelle

L’expérience de connexion universelle est localisée dans les langues suivantes :

| Langue                     | Code     |
| -------------------------- | -------- |
| Albanais                   | `sq`     |
| Allemand                   | `de`     |
| Amharic                    | `am`     |
| Anglais                    | `en`     |
| Anglais – Canada           | `en-CA`  |
| Arménien                   | `hy`     |
| Azerbaïdjanais             | `az`     |
| Basque                     | `eu-ES`  |
| Bengali                    | `bn`     |
| Bosniaque                  | `bs`     |
| Bulgare                    | `bg`     |
| Catalan                    | `ca-ES`  |
| Chinois – Hong Kong        | `zh-HK`  |
| Chinois – Simplifié        | `zh-CN`  |
| Chinois – Traditionnel     | `zh-TW`  |
| Coréen                     | `ko`     |
| Croate                     | `hr`     |
| Danois                     | `da`     |
| Espagnol                   | `es`     |
| Espagnol – Amérique latine | `es-419` |
| Espagnol – Argentine       | `es-AR`  |
| Espagnol –Mexique          | `es-MX`  |
| Estonien                   | `et`     |
| Finnois                    | `fi`     |
| Français                   | `fr-FR`  |
| Français – Canada          | `fr-CA`  |
| Galicien                   | `gl-ES`  |
| Gallois                    | `cy`     |
| Géorgien                   | `ka`     |
| Grec                       | `el`     |
| Gujrati                    | `gu`     |
| Hindi                      | `hi`     |
| Hongrois                   | `hu`     |
| Indonésien                 | `id`     |
| Islandais                  | `is`     |
| Italien                    | `it`     |
| Japonais                   | `ja`     |
| Kannada                    | `kn`     |
| Letton                     | `lv`     |
| Lituanien                  | `lt`     |
| Macédonien                 | `mk`     |
| Malais                     | `ms`     |
| Malayalam                  | `ml`     |
| Marathi                    | `mr`     |
| Mongolien                  | `mn`     |
| Monténegrin                | `cnr`    |
| Myanmar                    | `my`     |
| Néerlandais                | `nl`     |
| Norvégien                  | `no`     |
| Norvégien – Bokmål         | `nb`     |
| Norvégien – Nynorsk        | `nn`     |
| Polonais                   | `pl`     |
| Portugais – Brésil         | `pt-BR`  |
| Portugais – Portugal       | `pt-PT`  |
| Pendjabi                   | `pa`     |
| Roumain                    | `ro`     |
| Russe                      | `ru`     |
| Serbe                      | `sr`     |
| Slovaque                   | `sk`     |
| Slovène                    | `sl`     |
| Somali                     | `so`     |
| Swahili                    | `sw`     |
| Suédois                    | `sv`     |
| Tagalog                    | `tl`     |
| Tamazight                  | `zgh`    |
| Tamoul                     | `ta`     |
| Tchèque                    | `cs`     |
| Telugu                     | `te`     |
| Thaï                       | `th`     |
| Turc                       | `tr`     |
| Ukrainien                  | `uk`     |
| Vietnamien                 | `vi`     |

### Choix de la langue

La langue dans laquelle les pages seront affichées sera sélectionnée en fonction  :

* des langues prises en charge par Auth0, qui sont susmentionnées.
* La liste des langues configurées dans les paramètres du locataire, où vous pouvez sélectionner les langues que votre locataire prend en charge et en choisir une par défaut. Par défaut, la liste n’a que l’anglais sélectionné, mais vous pouvez choisir celles dont vous avez besoin.
* La valeur du paramètre `ui_locales` envoyée au [point de terminaison de demande d’autorisation](https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest), qui peut être utilisée pour restreindre la liste des langues pour une application ou une session. Vous pouvez fournir une liste de locales délimitée par des espaces. La première locale de la liste doit correspondre à la locale activée dans votre locataire pour se refléter dans l’interface utilisateur.
* L’en-tête HTTP `Accept-Language` envoyé par le navigateur. Les pages seront affichées dans cette langue si elle est autorisée par les paramètres ci-dessus. Sinon, les pages seront affichées dans la langue par défaut.

Pour ajouter une langue qui n’est pas répertoriée ci-dessus, utilisez <Tooltip href="/docs/fr-ca/glossary?term=management-api" tip="Management API
Un produit permettant aux clients d’effectuer des tâches administratives." cta="Voir le glossaire">Management API</Tooltip> pour créer un appel `PATCH` au [point de terminaison des locataires](https://auth0.com/docs/api/management/v2/tenants/patch-settings) avec le corps suivant, en remplacement `he` avec le code langue que vous souhaitez ajouter :

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

Une fois ajouté, spécifiez la langue dans le paramètre de requête **ui\_locales** de la demande de connexion.

### Définir les langues prises en charge par le locataire

Vous pouvez définir les langues prises en charge et celles par défaut dans la section [Tenant Settings (Paramètres du locataire)](https://manage.auth0.com/#/tenant) dans le Dashboard.

Vous pouvez également spécifier les langues activées pour le locataire par le biais de Management API en utilisant le [point de terminaison Mettre à jour les paramètres du locataire](/docs/fr-ca/api/management/v2#!/Tenants/patch_settings). La première langue de la liste sera la langue par défaut.

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

  ```objc Obj-C theme={null}
  #import <Foundation/Foundation.h>

  NSDictionary *headers = @{ @"content-type": @"application/json",
                             @"authorization": @"Bearer API2_ACCESS_TOKEN" };
  NSDictionary *parameters = @{ @"enabled_locales": @[ @"en", @"es" ] };

  NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/api/v2/tenants/settings"]
                                                         cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                     timeoutInterval:10.0];
  [request setHTTPMethod:@"PATCH"];
  [request setAllHTTPHeaderFields:headers];
  [request setHTTPBody:postData];

  NSURLSession *session = [NSURLSession sharedSession];
  NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                              completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                  if (error) {
                                                      NSLog(@"%@", error);
                                                  } else {
                                                      NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                      NSLog(@"%@", httpResponse);
                                                  }
                                              }];
  [dataTask resume];
  ```

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

  ```swift Swift theme={null}
  import Foundation

  let headers = [
    "content-type": "application/json",
    "authorization": "Bearer API2_ACCESS_TOKEN"
  ]
  let parameters = ["enabled_locales": ["en", "es"]] as [String : Any]

  let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

  let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/api/v2/tenants/settings")! as URL,
                                          cachePolicy: .useProtocolCachePolicy,
                                      timeoutInterval: 10.0)
  request.httpMethod = "PATCH"
  request.allHTTPHeaderFields = headers
  request.httpBody = postData as Data

  let session = URLSession.shared
  let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
    if (error != nil) {
      print(error)
    } else {
      let httpResponse = response as? HTTPURLResponse
      print(httpResponse)
    }
  })

  dataTask.resume()
  ```
</AuthCodeGroup>

### Limites

* Le paramètre `ui_locales` ne peut être utilisé que dans les flux <Tooltip href="/docs/fr-ca/glossary?term=oath2" tip="OAuth 2.0
  Cadre d’applications d’autorisation qui définit les protocoles d’autorisation et les flux de production." cta="Voir le glossaire">OAuth</Tooltip>, car il n’est pas disponible dans <Tooltip href="/docs/fr-ca/glossary?term=security-assertion-markup-language" tip="Security Assertion Markup Language (SAML)
  Protocole normalisé permettant à deux parties d’échanger des informations d’authentification sans mot de passe." cta="Voir le glossaire">SAML</Tooltip> ou WS-Federation.
* Le paramètre `ui_locales`  n’est pas transmis aux fournisseurs d’identité (<Tooltip href="/docs/fr-ca/glossary?term=idp" tip="Fournisseur d’identité (IdP)
  Service de stockage et de gestion des identités numériques." cta="Voir le glossaire">IdP</Tooltip>) en amont. Pour en savoir plus sur le passage de paramètres aux fournisseurs d’identité, consultez [Transmettre les paramètres aux fournisseurs d’identité](/docs/fr-ca/authenticate/identity-providers/pass-parameters-to-idps).
* Il n’est pas possible de localiser les permissions dans la page de Consentement.

### Problèmes connus

* L’ULP rend l’attribut HTML `lang` pour le code de langue `fr-FR` en tant que `fr`.
* L’ULP rend l’attribut HTML `lang` pour le code de langue `pt-PT` en tant que `pt`.

## Localisation de la connexion classique

Dans l’expérience de connexion classique, la localisation (traduction) se fait à l’aide de nos gadgets logiciels JavaScript pour la [connexion](/docs/fr-ca/customize/internationalization-and-localization/lock-internationalization), la [page de réinitialisation du mot de passe](/docs/fr-ca/customize/login-pages/classic-login/customize-password-reset-page) et les [politiques liées au mot de passe](/docs/fr-ca/customize/internationalization-and-localization/password-options-translation).

La [page MFA](/docs/fr-ca/secure/multi-factor-authentication/customize-mfa/customize-mfa-classic-login) utilise par défaut le gadget logiciel Auth0 <Tooltip href="/docs/fr-ca/glossary?term=multifactor-authentication" tip="Authentification multifacteur (MFA)
Processus d’authentification de l’utilisateur qui utilise un facteur en plus du nom d’utilisateur et du mot de passe, tel qu’un code par SMS." cta="Voir le glossaire">MFA</Tooltip>, qui ne peut pas être localisé. Vous pouvez créer des versions localisées en utilisant [guardian.js](https://github.com/auth0/auth0-guardian.js).

Il n’est pas possible de localiser la page de Consentement.

## En savoir plus

* [Personnaliser les modèles de pages de connexion universelle](/docs/fr-ca/customize/login-pages/universal-login/customize-templates)
* [Personnaliser les pages de connexion classiques avec Lock ou une trousse SDK](/docs/fr-ca/customize/login-pages/classic-login/customize-with-lock-sdk)