Authenticate users with a one-time code via SMS

With the SMS connection, the user is requested to enter a phone number. Auth0 then uses Twilio to send a one time code to that number.

Once the user enters this code into your application, a new user will be created in the sms connection. The user is then authenticated by Auth0.

If the phone number matches an existing user, Auth0 just authenticates the user:

On mobile platforms, your application will receive an id_token, the user profile and, optionally, a refresh_token.

Setup

1. Open an account with Twilio

You will need a Twilio Account SID and a Twilio Auth Token. These are the Twilio API credentials that Auth0 will use to send an SMS to the user.

2. Configure the connection

In the Dashboard under Connections > Passwordless, set the SMS slider to the right to enable the SMS Passwordless feature.

Enter your Twilio Account SID and Twilio Auth Token in the appropriate fields.

NOTE: For information on obtaining a Twilio SID and Auth Token, see: How to create an Application SID and Auth Tokens and how to change them.

Select the SMS Source that users will see as the sender of the SMS.

NOTE: For information on using Copilot, see: Sending Messages with Copilot.

Enter either your Twilio Messaging Service SID or a From phone number, depending on the SMS Source selected above.

Lastly, enter the Message that will appear in the body of the SMS.

NOTE: The @@password@@ placeholder in the Message will be automatically replaced with the one-time password that is sent to the user.

Click SAVE.

Multi-Language Support

The Message area supports usage of multiple languages.

By making a call to the /passwordless/start authentication endpoint, you can set the value of an 'x-request-language' header to the language of your choice. If the value of this header is not set, the language will be extracted from the value in the 'accept-language' header that is automatically set by the browser.

The Message area accepts Liquid syntax. You can use this syntax, combined with exposed parameter values, to programmatically construct elements of the message. For example, you can reference the request_language parameter to change the language of the message:

{% if request_language contains 'dutch' %}
   Hier is uw verificatie code: {{ password }}
{% endif %}

{% if request_language contains 'fr-FR' %}
   Ceci est votre code: {{ password }}
{% endif %}

The following paramaters are available when defining the template:

Exposed Parameter Description
password or code the password to use
phone_number the user's phone number
application.name the name of the application name where the user is signing up
request_language the requested language for the message content

3. Enable your apps

Go to the Apps tab of the SMS settings and enable the apps for which you would like to use Passwordless SMS.

Implementation

Using Auth0 Lock

Sample Project

Download this sample project configured with your Auth0 API Keys.

The Lock is a widget that allows you to easily integrate Auth0's Passwordless Authentication into your Android applications.

After installing and configuring Lock.Android you will be able to use Lock as follows.

Begin by adding the Lock SMS library to your build.gradle file:

compile 'com.auth0.android:lock-sms:1.10.+'

Once the user is successfully authenticated, LockActivity will send an Action using LocalBroadcasterManager and then end itself by calling finish(). The activity that will receive this Action and will show Lock needs to register a listener in the LocalBroadcastManager:

// This activity will show Lock
public class HomeActivity extends Activity {
  private LocalBroadcastManager broadcastManager;

  private BroadcastReceiver authenticationReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
      UserProfile profile = intent.getParcelableExtra(Lock.AUTHENTICATION_ACTION_PROFILE_PARAMETER);
      Token token = intent.getParcelableExtra(Lock.AUTHENTICATION_ACTION_TOKEN_PARAMETER);
      Log.i(TAG, "User " + profile.getName() + " logged in");
    }
  };

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //Customize your activity

    broadcastManager = LocalBroadcastManager.getInstance(this);
    broadcastManager.registerReceiver(authenticationReceiver, new IntentFilter(Lock.AUTHENTICATION_ACTION));
  }

  @Override
  protected void onDestroy() {
    super.onDestroy();
    broadcastManager.unregisterReceiver(authenticationReceiver);
  }
}

Then just call the activity:

Intent smsIntent = new Intent(this, LockSMSActivity.class);
startActivity(smsIntent);

When this code runs, it will ask the user for their phone number:

Then Auth0 will use Twilio to send to the user an SMS containing the one-time code:

Lastly, the user enters the one-time password into Lock. Then, if the password is correct, the user is authenticated.

Using your own UI

If you choose to build your own UI, first ask the user for their phone number. Then call requestSMSVerificationCode on the APIClient

final APIClient client = lock.getAPIClient();
client.requestSMSVerificationCode(phoneNumber, new BaseCallback<Void>() {
    @Override
    public void onSuccess(Void payload) {
        // SMS sent, continue to next page.
    }

    @Override
    public void onFailure(Throwable error) {
        // Error sending email.
    }
});

Once the passwordless login process begins, ask the user for the one-time code. Then authenticate using that code:

final APIClient client = lock.getAPIClient();
client.smsLogin(phoneNumber, passcode, authenticationParameters, new AuthenticationCallback() {
    @Override
    public void onSuccess(UserProfile userProfile, Token token) {
        // Login success, you can now use the userProfile or token
    }

    @Override
    public void onFailure(Throwable throwable) {
        // Login failed.
    }
});