Universal Login Internationalization

Universal Login localization

The Universal Login experience is localized to the following languages:

Language Code
Albanian sq
Amharic am
Armenia hy
Azerbaijani az
Basque eu-ES
Bengali bn
Bosnian bs
Bulgarian bg
Catalan ca-ES
Chinese - Hong Kong zh-HK
Chinese - Simplified zh-CN
Chinese - Traditional zh-TW
Croatian hr
Czech cs
Danish da
Dutch nl
English en
English - Canada en-CA
Estonian et
Finnish fi
French fr-FR
French - Canada fr-CA
Galician gl-ES
Georgian ka
German de
Greek el
Gujrati gu
Hindi hi
Hungarian hu
Icelandic is
Indonesian id
Italian it
Japanese ja
Kannada kn
Korean ko
Latvian lv
Lithuanian lt
Macedonian mk
Malay ms
Malayalam ml
Marathi mr
Mongolian mn
Montenegrine cnr
Myanmar my
Norwegian no
Norwegian - Bokmål nb
Norwegian - Nynorsk nn
Polish pl
Portuguese - Brazil pt-BR
Portuguese - Portugal pt-PT
Punjabi pa
Romanian ro
Russian ru
Serbian sr
Slovak sk
Slovenian sl
Somali so
Spanish es
Spanish - Argentina es-AR
Spanish - Latin America es-419
Spanish - Mexico es-MX
Swahili sw
Swedish sv
Tagalog tl
Tamazight zgh
Tamil ta
Telugu te
Thai th
Turkish tr
Ukrainian uk
Vietnamese vi
Welsh cy

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 selected, but you can select the ones you need.

  • 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. You can provide a space-delimited list of locales. The first locale on the list must match the enabled locale in your tenant to reflect in the UI.

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

Set 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://{yourDomain}/api/v2/tenants/settings' \
  --header 'authorization: Bearer API2_ACCESS_TOKEN' \
  --header 'content-type: application/json' \
  --data '{ "enabled_locales" : [ "en", "es"]}'

Was this helpful?

/
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);

Was this helpful?

/
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))

}

Was this helpful?

/
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();

Was this helpful?

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

Was this helpful?

/
#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];

Was this helpful?

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

Was this helpful?

/
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"))

Was this helpful?

/
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

Was this helpful?

/
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()

Was this helpful?

/

Limitations

  • It is not possible to add additional languages.

  • 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. To learn more about passing parameters to IdPs, read Pass Parameters to Identity Providers.

  • It is not possible to localize the scopes in the Consent page.

Known issues

  • The ULP renders the HTML lang attribute for the language code fr-FR as fr.

  • The ULP renders the HTML lang attribute for the language code pt-PT as pt.

Classic Login localization

In the Classic 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.

Learn more