Voice API Overview

The Vonage 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). (Nexmo is now Vonage).
Record and store inbound or outbound calls
Create conference calls
Send text-to-speech messages in 40 languages with different genders and accents

In this document you can learn about:

Vonage Voice API Concepts to introduce terminology
How to Get Started with the Voice API including examples in your language
Guides learn about working with the Voice API
Code Snippets code snippets to help with specific tasks
Use Cases detailed use cases with code examples
Reference API documentation and other supporting content

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 Vonage Voice Application ID and a Private Key. For more information see authenticating your applications.
Nexmo Voice Applications - Vonage 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 Vonage Voice Applications using the Vonage Dashboard, the Nexmo CLI, or via the Application API.
NCCOs - Nexmo Call Control Objects are a set of actions that instruct Vonage how to control the call to your Vonage 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 Vonage 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 Vonage API 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 Vonage Voice Apps

Using the API

The primary way that you'll interact with the Vonage API 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, Vonage 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 Vonage 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`.

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

Install the CLI

npm install -g nexmo-cli

Create an application

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

const ANSWER_URL = 'https://developer.nexmo.com/ncco/tts.json'

nexmo.calls.create({
  to: [{
    type: 'phone',
    number: TO_NUMBER
  }],
  from: {
    type: 'phone',
    number: NEXMO_NUMBER
  },
  answer_url: [ANSWER_URL]
}, (error, response) => {
  if (error) console.error(error)
  if (response) console.log(response)
})

View full source

Run your code

Save this file to your machine and run it:

node make-call.js

Prerequisites

Create an application

Install the CLI

npm install -g nexmo-cli

Create an application

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.2.1'

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

Install the CLI

npm install -g nexmo-cli

Create an application

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

Import dependencies

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

Copy to Clipboard

using Nexmo.Api;
using Nexmo.Api.Request;
using Nexmo.Api.Voice;
using Nexmo.Api.Voice.Nccos.Endpoints;

View full source

Initialize your dependencies

Add the following to MakeOutboundCall.cs:

Copy to Clipboard

var creds = Credentials.FromAppIdAndPrivateKeyPath(NEXMO_APPLICATION_ID, NEXMO_PRIVATE_KEY_PATH);
var client = new NexmoClient(creds);

View full source

Write the code

Add the following to MakeOutboundCall.cs:

Copy to Clipboard

var command = new CallCommand() { To = new Endpoint[] { toEndpoint }, From = fromEndpoint, AnswerUrl = new[] { ANSWER_URL } };
var response = client.VoiceClient.CreateCall(command);

View full source

Prerequisites

Create an application

Install the CLI

npm install -g nexmo-cli

Create an application

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

Install the CLI

npm install -g nexmo-cli

Create an application

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

Install the CLI

npm install -g nexmo-cli

Create an application

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.voice.create(
  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'
  ]
)

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.
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).
Numbers: Numbers are a key part of using the Nexmo Voice API. This guide covers number formatting, outgoing caller IDs and incoming call numbers.
Nexmo Call Control Objects: To tell Vonage how to handle a phone call, you must provide a Nexmo Call Control Objects (NCCO) when a call is placed or answered. There are various actions available, such as talk, input and record.
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
Endpoints: When connecting a call, you can connect to another phone number, a sip endpoint or a websocket. These are known as endpoints.
Recording: Recording audio input from a caller or recording the conversation between two callers.
Speech Recognition: Capture user input by converting user speech to text form during a call.
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.

Voice API Overview

Contents

Concepts

Getting Started

Voice Playground

Using the API

Prerequisites

Create an application

Install the CLI

Create an application

Generate your JWT

Write the code

Run your code

Prerequisites

Create an application

Install the CLI

Create an application

Install dependencies

Initialize your dependencies

Write the code

Run your code

Prerequisites

Create an application

Install the CLI

Create an application

Install dependencies

Initialize your dependencies

Write the code

Run your code

Prerequisites

Create an application

Install the CLI

Create an application

Install dependencies

Import dependencies

Initialize your dependencies

Write the code

Prerequisites

Create an application

Install the CLI

Create an application

Install dependencies

Initialize your dependencies

Write the code

Run your code

Prerequisites

Create an application

Install the CLI

Create an application

Install dependencies

Initialize your dependencies

Write the code

Run your code

Prerequisites

Create an application

Install the CLI

Create an application

Install dependencies

Initialize your dependencies

Write the code

Run your code

Guides

Code Snippets

Use Cases

Reference