Universal Login Internationalization

Universal Login Internationalization

Internationalization in the New Universal Login Experience

The New Universal Login Experience is currently localized to the languages below, with more languages to be added over time:

Code Language
da Danish
de German
en English
es Spanish
fi Finnish
fr French
hi Hindi
it Italian
ja Japanese
nb Norwegian
nl Dutch
pt-BR Portuguese (Brazilian)
pt-PT Portuguese (Portugal)
ru Russian
sv Swedish
zh-CN Chinese (Simplified)
zh-TW Chinese (Traditional)

Language Selection

The language to render the pages will be selected based on:

  • The languages supported by Auth0, which are listed above.
  • The list of languages configured in Tenant Settings, where you can select the languages your tenant supports and select a default one. By default, the list has only English, so if you want to support other languages you first need to update the list.
  • The value of the ui_locales parameter sent to the authorization request endpoint, which can be used to constrain the language list for an application or session.
  • The Accept-Language HTTP header sent by the browser. The pages will be rendered in this language if it is allowed by the settings above. If not, pages will be rendered in the default language.

Setting the tenant supported languages

You can set the supported and default languages in the Dashboard's Tenant Settings section.

You can also specify the enabled languages for the tenant via the Management API using the Update tenant settings endpoint. The first language in the list will be the default one.

curl --request PATCH \
  --url 'https://YOUR_DOMAIN/api/v2/tenants/settings' \
  --header 'authorization: Bearer API2_ACCESS_TOKEN' \
  --header 'content-type: application/json' \
  --data '{ "enabled_locales" : [ "en", "es"]}'
var client = new RestClient("https://YOUR_DOMAIN/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);
package main

import (

func main() {

	url := "https://YOUR_DOMAIN/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)


HttpResponse<String> response = Unirest.patch("https://YOUR_DOMAIN/api/v2/tenants/settings")
  .header("content-type", "application/json")
  .header("authorization", "Bearer API2_ACCESS_TOKEN")
  .body("{ \"enabled_locales\" : [ \"en\", \"es\"]}")
var request = require("request");

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

request(options, function (error, response, body) {
  if (error) throw new Error(error);

#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://YOUR_DOMAIN/api/v2/tenants/settings"]
[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];
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://YOUR_DOMAIN/api/v2/tenants/settings",
  CURLOPT_POSTFIELDS => "{ \"enabled_locales\" : [ \"en\", \"es\"]}",
    "authorization: Bearer API2_ACCESS_TOKEN",
    "content-type: application/json"

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


if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
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", "/YOUR_DOMAIN/api/v2/tenants/settings", payload, headers)

res = conn.getresponse()
data =

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://YOUR_DOMAIN/api/v2/tenants/settings")

http =, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request =
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
import Foundation

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

let postData = parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://YOUR_DOMAIN/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) {
  } else {
    let httpResponse = response as? HTTPURLResponse


Current Limitations

  • It is not possible for you to add additional languages (although Auth0 will be adding more over time).
  • It is not possible for you to override the copy for a specific piece of text.
  • The ui_locales parameter can only be used in OAuth flows, as it’s not available in SAML or WS-Federation.
  • The ui_locales parameter is not forwarded to upstream IdPs.
  • It is not possible to localize the scopes in the Consent page.

Internationalization in the Classic Universal Login Experience

In the Classic Universal Login experience, localization is done using our JavaScript widgets for login, the password reset page and password policies.

The MFA page by default uses the Auth0 MFA Widget, which cannot be localized. You can create localized versions by using guardian.js.

It is not possible to localize the Consent page.