Two Factor Authentication for Voice - Python


By adding 2FA to your application, you can provide your users effective protection against many security threats that target user passwords and accounts. It will generate a One-Time Password to their phone number via voice call. Application developers can enable two-factor authentication for their users with ease and without making any changes to the already existing application logic or database structure! This guide uses the Python SignalWire SDK to show an example of how that can be done!

What do I need to run this code?

Find the full code on Github here

You will need a signalwire account which you can create here. You will also need your SignalWire API credentials which you can find in the API tab of your SignalWire dashboard. For more information on navigating your SignalWire space check here.

Additionally you will need the SignalWire Python SDK, the Requests module, and Flask

How to Run this Application

Setup Your Environment File

  1. Copy from example.env and fill in your values
  2. Save new file called .env

Your file should look something like this

## This is the full name of your SignalWire Space. e.g.:
# Your Project ID - you can find it on the `API` page in your Dashboard.
# Your API token - you can generate one on the `API` page in your Dashboard
# The phone number you'll be using for this guide. Must include the `+1` , e.g.: +15551234567

Build from Docker Hub

docker pull signalwire/snippets-voice-two-factor-auth:python


Build your Own Docker Image

docker build -t snippets-voice-two-factor-auth


Run your image

docker run --publish 5000:5000 --env-file .env snippets-voice-two-factor-auth
  1. The application will run on port 5000

Build and Run Natively

To run the application, execute export then run flask run.

You may need to use an SSH tunnel for testing this code if running on your local machine. – we recommend ngrok. You can learn more about how to use ngrok here.

Step-by-Step Walkthrough

In the Github Repo you will find the, License, and a python folder.

In the python folder there is a Dockerfile, our example.env file for our environment variables, and the file where our application lives.

Into the code

We need to start by creating variables to store all the data from the authentication session.

data = {}
data['requests'] = []

Code Verification

Next, we will define a function that looks up the phone number and verifies that the code is correct. We will loop through all authentication sessions, and check if there is a matching number while first adding a + to make sure the number is in E164 format. If there is a session matching that number, we will complete our second check to see if the code they provided was correct. If both conditions are satisfied, we will remove the validated session from the data dictionary created above.

def lookup_code(number,code):

    # Loop through all sessions
    for i in range(len(data['requests'])):
        # Look if number is equal to a number in a session, we are prepending a '+'
        if '+' + number == data['requests'][i]['number']:
            # Great, We found a session matching that number, now let us check the challenge code
            if code == data['requests'][i]['code']:
                # We have a match, let's remove the validated session and return true
                return True
    # Catch all for failed challenges
    return False

Flask Routes Setup


Now that we have defined our variables and our functions, we need to move on to the Flask routes! We will start by defining a route called /validate-auth that will validate the authentication request. We will grab the authorization code and the phone number from the GET/POST request and call our previously defined lookup_code(number, code) function. If the lookup & authentication are successful, we will return a 200OK. If the lookup is unsuccessful, we will return a 403 FORBIDDEN.

# Listen for '/validate-auth' route
def validate_auth():
    # Grab the authorization code from the GET/POST request
    check_code = request.values.get('auth_code')
    # Grab the phone number from the GET/POST request
    number = request.values.get('number')

    # Verify the number and challenge code
    if lookup_code(number, check_code):
        # Return 200, On Accept
        return "200"

    # Return 403, On Forbidden
    return "403"


The next route we define is what will be called when you want to create an authentication request. We start by instantiating the SignalWire client using the Project ID, Auth Token, and Space URL. Then we will generate a random 6 digit code between 123456 and 987654. Next, we get the phone number that we're going to send the call to and add both the code and number to our global data object. Lastly, we will use the Create Call API in order to send a call to the requested number with the generated code.

@app.route('/request-auth', methods=['GET', 'POST'])
def request_auth():

    client = signalwire_client(os.environ['SIGNALWIRE_PROJECT'], os.environ['SIGNALWIRE_TOKEN'], signalwire_space_url = os.environ['SIGNALWIRE_SPACE'])

    auth_code = str(random.randint(123456,987654))
    number = "+" + request.values.get('number')

        'number': number,
        'code': auth_code

    call = client.calls.create(
        from_ = os.environ['SIGNALWIRE_NUMBER'],
          url = "http://" + os.environ['HOSTNAME'] + "/call_2fa?auth_code=" + auth_code,
           to = number

    return "200"


Our last route will be used in order to read out the authorization code over the phone call. We will start by getting the auth code from the query params passed in when creating the call in the previous route. We will also instantiate VoiceResponse() so that we can use text to speech. Lastly, we will use text to speech to repeat the authorization code twice for the end user and then hang up!

@app.route('/call_2fa', methods=['GET', 'POST'])
def call_2fa():

    auth_code = request.values.get('auth_code')
    response = VoiceResponse()

    response.say('Your authorization code is: ' + auth_code )
    response.say('Your authorization code is: ' + auth_code )
    response.say('Thank you for calling, GoodBye!')

    return str(response)

Wrap Up

Two Factor Authentication is a great tool and this guide demonstrates how easy it is to integrate an extra layer of protection into your projects using the SignalWire python SDK.


Github Repo
Python SignalWire SDK

Sign Up Here

If you would like to test this example out, you can create a SignalWire account and space here.

Please feel free to reach out to us on our Community Slack or create a Support ticket if you need guidance!

What’s Next

Check out the full code on our SignalWire Github Repo!

Did this page help you?