Voice API Overview

The Nexmo Voice API is the easiest way to build high-quality voice applications in the Cloud. With the Voice API you can:

  • Build apps that scale with the web technologies you are already using
  • Control the flow of inbound and outbound calls in JSON with Nexmo Call Control Objects (NCCO)
  • Record and store inbound or outbound calls
  • Create conference calls
  • Send text-to-speech messages in 40 languages with different genders and accents

Contents

In this document you can learn about:

Concepts

  • Authentication with JWTs - interaction with the Voice API are authenticated using JWTs (JSON Web Tokens). The Nexmo libraries handle JWT generation using a unique Nexmo Voice Application ID and a Private Key. For more information see authenticating your applications.

  • Nexmo Voice Applications - Nexmo Voice Applications represent a one-to-one mapping with the application that you are building. They contain configuration such as virtual numbers and webhook callback URLs. You can create Nexmo Voice Applications using the Nexmo Dashboard, the Nexmo CLI, or via the Application API.

  • NCCOs - Nexmo Call Control Objects are a set of actions that instruct Nexmo how to control the call to your Nexmo application. For example, you can connect a call, send synthesized speech using talk, stream audio, or record a call. They are represented in JSON form as an Array of objects. For more information see the NCCO Reference.

  • Numbers - The key concepts of using phone numbers in the Nexmo Voice API.

  • Webhooks - HTTP requests are made to your application web server so that you can act upon them. For example, an incoming call will send a webhook.

Getting Started

Voice Playground

In the Nexmo Dashboard, you can try out the Voice API interactively in the Voice Playground. Once you are signed up for a Nexmo account, you can go to Voice Playground in the Dashboard (Voice ‣ Voice Playground).

More details are available in this blog post: Meet Voice Playground, Your Testing Sandbox for Nexmo Voice Apps

Using the API

The primary way that you'll interact with the Nexmo voice platform is via the public API. To place an outbound call, you make a POST request to https://api.nexmo.com/v1/calls.

To make this easier, Nexmo provides Server SDKs in various languages that take care of authentication and creating the correct request body for you.

To get started, choose your language below and replace the following variables in the example code:

Key Description
NEXMO_NUMBER Your Nexmo number that the call will be made from. For example 447700900000.
TO_NUMBER The number you would like to call to in E.164 format. For example 447700900001.
  • cURL
  • Node.js
  • Java
  • .NET
  • PHP
  • Python
  • Ruby

    • Prerequisites

    Create an application

    A Nexmo application contains the required configuration for your project. You can create an application using the Nexmo CLI (see below) or via the dashboard. To learn more about applications see our Nexmo concepts guide.

    Install the CLI

    npm install -g nexmo-cli

    Create an application

    Once you have the CLI installed you can use it to create a Nexmo application. Run the following command and make a note of the application ID that it returns. This is the value to use in NEXMO_APPLICATION_ID in the example below. It will also create private.key in the current directory which you will need in the Initialize your dependencies step

    Nexmo needs to connect to your local machine to access your answer_url. We recommend using ngrok to do this. Make sure to change demo.ngrok.io in the examples below to your own ngrok URL.

    nexmo app:create "Outbound Call code snippet" https://developer.nexmo.com/ncco/tts.json http://demo.ngrok.io/webhooks/events --keyfile private.key
    Generate your JWT

    Execute the following command at your terminal prompt to create the JWT for authentication:

    export JWT=$(nexmo jwt:generate $PATH_TO_PRIVATE_KEY application_id=$NEXMO_APPLICATION_ID)

    Write the code

    Add the following to make-an-outbound-call.sh:

    Copy to Clipboard 
    curl -X POST https://api.nexmo.com/v1/calls\
  -H "Authorization: Bearer "$JWT\
  -H "Content-Type: application/json"\
  -d '{"to":[{"type": "phone","number": "'$TO_NUMBER'"}],
      "from": {"type": "phone","number": "'$NEXMO_NUMBER'"},
      "answer_url":["https://raw.githubusercontent.com/nexmo-community/ncco-examples/gh-pages/text-to-speech.json"]}'

    View full source

    Run your code

    Save this file to your machine and run it: 

    bash make-an-outbound-call.sh

    Prerequisites

    Create an application

    A Nexmo application contains the required configuration for your project. You can create an application using the Nexmo CLI (see below) or via the dashboard. To learn more about applications see our Nexmo concepts guide.

    Install the CLI

    npm install -g nexmo-cli

    Create an application

    Once you have the CLI installed you can use it to create a Nexmo application. Run the following command and make a note of the application ID that it returns. This is the value to use in NEXMO_APPLICATION_ID in the example below. It will also create private.key in the current directory which you will need in the Initialize your dependencies step

    Nexmo needs to connect to your local machine to access your answer_url. We recommend using ngrok to do this. Make sure to change demo.ngrok.io in the examples below to your own ngrok URL.

    nexmo app:create "Outbound Call code snippet" https://developer.nexmo.com/ncco/tts.json http://demo.ngrok.io/webhooks/events --keyfile private.key
    Install dependencies

    npm install nexmo
    Initialize your dependencies

    Create a file named make-call.js and add the following code:

    Copy to Clipboard 
    const Nexmo = require('nexmo')

const nexmo = new Nexmo({
  apiKey: NEXMO_API_KEY,
  apiSecret: NEXMO_API_SECRET,
  applicationId: NEXMO_APPLICATION_ID,
  privateKey: NEXMO_APPLICATION_PRIVATE_KEY_PATH
})

    View full source

    Write the code

    Add the following to make-call.js:

    Copy to Clipboard 
    nexmo.calls.create({
  to: [{
    type: 'phone',
    number: TO_NUMBER
  }],
  from: {
    type: 'phone',
    number: NEXMO_NUMBER
  },
  answer_url: ['https://developer.nexmo.com/ncco/tts.json']
})

    View full source

    Run your code

    Save this file to your machine and run it: 

    node make-call.js

    Prerequisites

    Create an application

    A Nexmo application contains the required configuration for your project. You can create an application using the Nexmo CLI (see below) or via the dashboard. To learn more about applications see our Nexmo concepts guide.

    Install the CLI

    npm install -g nexmo-cli

    Create an application

    Once you have the CLI installed you can use it to create a Nexmo application. Run the following command and make a note of the application ID that it returns. This is the value to use in NEXMO_APPLICATION_ID in the example below. It will also create private.key in the current directory which you will need in the Initialize your dependencies step

    Nexmo needs to connect to your local machine to access your answer_url. We recommend using ngrok to do this. Make sure to change demo.ngrok.io in the examples below to your own ngrok URL.

    nexmo app:create "Outbound Call code snippet" https://developer.nexmo.com/ncco/tts.json http://demo.ngrok.io/webhooks/events --keyfile private.key
    Install dependencies

    Add the following to build.gradle:

    compile 'com.nexmo:client:5.1.0'
    Initialize your dependencies

    Create a class named OutboundTextToSpeech and add the following code to the main method:

    Copy to Clipboard 
    NexmoClient client = NexmoClient.builder()
        .applicationId(NEXMO_APPLICATION_ID)
        .privateKeyPath(NEXMO_PRIVATE_KEY_PATH)
        .build();

    View full source

    Write the code

    Add the following to the main method of the OutboundTextToSpeech class:

    Copy to Clipboard 
    client.getVoiceClient().createCall(new Call(TO_NUMBER, NEXMO_NUMBER, ANSWER_URL));

    View full source

    Run your code

    We can use the application plugin for Gradle to simplify the running of our application. Update your build.gradle with the following:

    apply plugin: 'application'
mainClassName = project.hasProperty('main') ? project.getProperty('main') : ''

    Run the following gradle command to execute your application, replacing com.nexmo.quickstart.voice with the package containing OutboundTextToSpeech:

    gradle run -Pmain=com.nexmo.quickstart.voice.OutboundTextToSpeech

    Prerequisites

    Create an application

    A Nexmo application contains the required configuration for your project. You can create an application using the Nexmo CLI (see below) or via the dashboard. To learn more about applications see our Nexmo concepts guide.

    Install the CLI

    npm install -g nexmo-cli

    Create an application

    Once you have the CLI installed you can use it to create a Nexmo application. Run the following command and make a note of the application ID that it returns. This is the value to use in NEXMO_APPLICATION_ID in the example below. It will also create private.key in the current directory which you will need in the Initialize your dependencies step

    Nexmo needs to connect to your local machine to access your answer_url. We recommend using ngrok to do this. Make sure to change demo.ngrok.io in the examples below to your own ngrok URL.

    nexmo app:create "Outbound Call code snippet" https://developer.nexmo.com/ncco/tts.json http://demo.ngrok.io/webhooks/events --keyfile private.key
    Install dependencies

    Install-Package Nexmo.Csharp.Client
    Initialize your dependencies

    Create a file named VoiceSender.cs and add the following code:

    Copy to Clipboard 
    var client = new Client(creds: new Nexmo.Api.Request.Credentials
{
    ApiKey = "NEXMO_API_KEY",
    ApiSecret = "NEXMO_API_SECRET",
    ApplicationId = "NEXMO_APPLICATION_ID",
    ApplicationKey = "NEXMO_APPLICATION_PRIVATE_KEY"
});

    View full source

    Write the code

    Add the following to VoiceSender.cs:

    Copy to Clipboard 
    var results = client.Call.Do(new Call.CallCommand
{
    to = new[]
    {
        new Call.Endpoint {
            type = "phone",
            number = TO_NUMBER
        }
    },
    from = new Call.Endpoint
    {
        type = "phone",
        number = NEXMO_NUMBER
    },
    answer_url = new[]
    {
        "https://developer.nexmo.com/ncco/tts.json"
    }
});

    View full source

    Prerequisites

    Create an application

    A Nexmo application contains the required configuration for your project. You can create an application using the Nexmo CLI (see below) or via the dashboard. To learn more about applications see our Nexmo concepts guide.

    Install the CLI

    npm install -g nexmo-cli

    Create an application

    Once you have the CLI installed you can use it to create a Nexmo application. Run the following command and make a note of the application ID that it returns. This is the value to use in NEXMO_APPLICATION_ID in the example below. It will also create private.key in the current directory which you will need in the Initialize your dependencies step

    Nexmo needs to connect to your local machine to access your answer_url. We recommend using ngrok to do this. Make sure to change demo.ngrok.io in the examples below to your own ngrok URL.

    nexmo app:create "Outbound Call code snippet" https://developer.nexmo.com/ncco/tts.json http://demo.ngrok.io/webhooks/events --keyfile private.key
    Install dependencies

    composer require nexmo/client
    Initialize your dependencies

    Create a file named index.php and add the following code:

    Copy to Clipboard 
    $keypair = new \Nexmo\Client\Credentials\Keypair(
    file_get_contents(NEXMO_APPLICATION_PRIVATE_KEY_PATH),
    NEXMO_APPLICATION_ID
);

$client = new \Nexmo\Client($keypair);

    View full source

    Write the code

    Add the following to index.php:

    Copy to Clipboard 
    $call = $client->calls()->create([
    'to' => [[
        'type' => 'phone',
        'number' => TO_NUMBER
    ]],
    'from' => [
        'type' => 'phone',
        'number' => NEXMO_NUMBER
    ],
    'answer_url' => ['https://developer.nexmo.com/ncco/tts.json'],
]);

    View full source

    Run your code

    Save this file to your machine and run it: 

    php -t . -S localhost:3000

    Prerequisites

    Create an application

    A Nexmo application contains the required configuration for your project. You can create an application using the Nexmo CLI (see below) or via the dashboard. To learn more about applications see our Nexmo concepts guide.

    Install the CLI

    npm install -g nexmo-cli

    Create an application

    Once you have the CLI installed you can use it to create a Nexmo application. Run the following command and make a note of the application ID that it returns. This is the value to use in NEXMO_APPLICATION_ID in the example below. It will also create private.key in the current directory which you will need in the Initialize your dependencies step

    Nexmo needs to connect to your local machine to access your answer_url. We recommend using ngrok to do this. Make sure to change demo.ngrok.io in the examples below to your own ngrok URL.

    nexmo app:create "Outbound Call code snippet" https://developer.nexmo.com/ncco/tts.json http://demo.ngrok.io/webhooks/events --keyfile private.key
    Install dependencies

    pip install nexmo
    Initialize your dependencies

    Create a file named make-an-outbound-call.py and add the following code:

    Copy to Clipboard 
    import nexmo
from pprint import pprint

client = nexmo.Client(
    application_id=APPLICATION_ID,
    private_key=APPLICATION_PRIVATE_KEY_PATH,
)

    View full source

    Write the code

    Add the following to make-an-outbound-call.py:

    Copy to Clipboard 
    response = client.create_call({
  'to': [{'type': 'phone', 'number': TO_NUMBER}],
  'from': {'type': 'phone', 'number': NEXMO_NUMBER},
  'answer_url': ['https://developer.nexmo.com/ncco/tts.json']
})

pprint(response)

    View full source

    Run your code

    Save this file to your machine and run it: 

    python3 make-an-outbound-call.py

    Prerequisites

    Create an application

    A Nexmo application contains the required configuration for your project. You can create an application using the Nexmo CLI (see below) or via the dashboard. To learn more about applications see our Nexmo concepts guide.

    Install the CLI

    npm install -g nexmo-cli

    Create an application

    Once you have the CLI installed you can use it to create a Nexmo application. Run the following command and make a note of the application ID that it returns. This is the value to use in NEXMO_APPLICATION_ID in the example below. It will also create private.key in the current directory which you will need in the Initialize your dependencies step

    Nexmo needs to connect to your local machine to access your answer_url. We recommend using ngrok to do this. Make sure to change demo.ngrok.io in the examples below to your own ngrok URL.

    nexmo app:create "Outbound Call code snippet" https://developer.nexmo.com/ncco/tts.json http://demo.ngrok.io/webhooks/events --keyfile private.key
    Install dependencies

    gem install nexmo
    Initialize your dependencies

    Create a file named outbound_tts_call.rb and add the following code:

    Copy to Clipboard 
    client = Nexmo::Client.new(
  api_key: NEXMO_API_KEY,
  api_secret: NEXMO_API_SECRET,
  application_id: NEXMO_APPLICATION_ID,
  private_key: File.read(NEXMO_APPLICATION_PRIVATE_KEY_PATH)
)

    View full source

    Write the code

    Add the following to outbound_tts_call.rb:

    Copy to Clipboard 
    response = client.calls.create(
  to: [{
    type: 'phone',
    number: TO_NUMBER
  }],
  from: {
    type: 'phone',
    number: NEXMO_NUMBER
  },
  answer_url: [
    'https://developer.nexmo.com/ncco/tts.json'
  ]
)

puts response.inspect

    View full source

    Run your code

    Save this file to your machine and run it: 

    ruby outbound_tts_call.rb

    Guides

    • Call Flow: The various stages of a call and how they interact.
    • Nexmo Call Control Objects: To tell Nexmo how to handle a phone call, you must provide Nexmo an Nexmo Call Control Objects (NCCO) when a call is placed or answered. There are various actions available, such as talk, input and record.
    • Numbers: Numbers are a key part of using the Nexmo Voice API. This guide covers number formatting, outgoing caller IDs and incoming call numbers.
    • Legs and Conversations: When a phone call is made or received by Nexmo it is added to a conversation. A single conversation contains one or more phone calls (sometimes referred to as legs).
    • Text to Speech: Using our Text-To-Speech engine, you can play machine-generated speech to your callers
    • Customizing Spoken Text: Use Speech Synthesis Markup Language (SSML) to control how text-to-speech is read out
    • Recording: Recording audio input from a caller or recording the conversation between two callers.
    • Endpoints: When connecting a call, you can connect to another phone number, a sip endpoint or a websocket. These are known as endpoints.
    • DTMF: Capture user input by detecting DTMF tones (button presses) during a call.
    • Websockets: You can connect the audio of a call to a websocket to work with it in real time.

    Code Snippets

    Use Cases

    Reference