Play Text During a Call

Latest Legacy

This endpoint lets you speak text in an active call.

API Endpoint

POST https://api.plivo.com/v1/Account/{auth_id}/Call/{call_uuid}/Speak/

Arguments

text Required	The text that needs to be spoken.
voice string	The voice in which the text should be spoken. Allowed values: MAN, WOMAN. Defaults to WOMAN.
language string	The language used to speak the text. The default language is US English (en-US). You can see the list of supported languages below.
legs string	The call leg in which the text is to be spoken. Allowed values: aleg (first leg of the call), bleg (second leg of the call), or both Defaults to aleg.
loop boolean	If set to true, the text will be spoken repeatedly unless stopped. Defaults to false.
mix boolean	This flag determines the behavior of current call audio when the file is being played. If set to false, then call participants cannot hear anyone speaking in the call until play is stopped. If set to true, both call audio and played audio are mixed and played. Defaults to true.

List of languages supported

Danish da-DK	Only WOMAN voice
Dutch nl-NL	Both WOMAN and MAN voices
English - Australian en-AU	Both WOMAN and MAN voices
English - British en-GB	Both WOMAN and MAN voices
English - USA en-US	Both WOMAN and MAN voices
French fr-FR	Both WOMAN and MAN voices
French - Canadian fr-CA	Only WOMAN voice
German de-DE	Both WOMAN and MAN voices
Italian it-IT	Both WOMAN and MAN voices
Polish pl-PL	Both WOMAN and MAN voices
Portugese pt-PT	Only MAN voice
Portugese - Brazilian pt-BR	Both WOMAN and MAN voices
Russian ru-RU	Only WOMAN voice
Spanish es-ES	Both WOMAN and MAN voices
Spanish - USA es-US	Both WOMAN and MAN voices
Swedish sv-SE	Only WOMAN voice

Returns

If successful, this endpoint returns an acknowledgement that the written text is being spoken in the call

Response

HTTP Status Code: 202

{
  "message": "speak started",
  "api_id": "07abfd94-58c0-11e1-86da-adf28403fe48"
}

Example Request

1
2
3
4
5
6
7
import plivo

client = plivo.RestClient('<auth_id>','<auth_token>')
response = client.calls.speak(
    call_uuid='3a2e4c90-dcee-4931-8a59-f123ab507e60',
    text='Hello World', )
print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#
# Example for Call Speak Create
#
require 'rubygems'
require 'plivo'

include Plivo
include Plivo::Exceptions

api = RestClient.new("<auth_id>","<auth_token>")

begin
  response = api.calls.speak(
    'eba53b9e-8fbd-45c1-9444-696d2172fbc8',
    'Hello World'
  )
  puts response
rescue PlivoRESTError => e
  puts 'Exception: ' + e.message
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Example for Call Speak create

var plivo = require('plivo');

(function main() {
    'use strict';
    
   // If auth id and auth token are not specified, Plivo will fetch them from the environment variables.
    var client = new plivo.Client("<auth_id>","<auth_token>");
    client.calls.speakText(
        "eba53b9e-8fbd-45c1-9444-696d2172fbc8", // call uuid
        "Hello World", // text
    ).then(function (response) {
        console.log(response);
    }, function (err) {
        console.error(err);
    });
})();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
/**
 * Example for Call Speak create
 */
require 'vendor/autoload.php';
use Plivo\RestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new RestClient("<auth_id>","<auth_token>");

try {
    $response = $client->calls->startSpeaking(
        'eba53b9e-8fbd-45c1-9444-696d2172fbc8',
        'Hello World'
    );
    print_r($response);
}
catch (PlivoRestException $ex) {
    print_r($ex);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.plivo.api.samples.call.speak;

import java.io.IOException;
import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.call.Call;
import com.plivo.api.models.call.actions.CallSpeakCreateResponse;

/**
* Example for Call Speak create
*/
class SpeakCreate {
    public static void main(String [] args) {
        Plivo.init("<auth_id>","<auth_token>");
        try {
            CallSpeakCreateResponse response = Call.speaker("eba53b9e-8fbd-45c1-9444-696d2172fbc8", "Hello World")
                .speak();

            System.out.println(response);
        } catch (PlivoRestException | IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * Example for Call Speak Create
 */
using System;
using System.Collections.Generic;
using Plivo;
using Plivo.Exception;

namespace PlivoExamples
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            var api = new PlivoApi("<auth_id>","<auth_token>");
            try
            {
                var response = api.Call.StartSpeaking(
                    callUuid:"93b35e56-5b28-47fc-95aa-8536625d3ac1",
                    text:"Hello World"
                );
                Console.WriteLine(response);
            }
            catch (PlivoRestException e)
            {
                Console.WriteLine("Exception: " + e.Message);
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Example for Call Speak create
package main

import "fmt"
import "github.com/plivo/plivo-go"
 
func main() {
	client, err := plivo.NewClient("<auth_id>","<auth_token>", &plivo.ClientOptions{})
	if err != nil {
			fmt.Print("Error", err.Error())
			return
		}
	response, err := client.Calls.Speak(
		"eba53b9e-8fbd-45c1-9444-696d2172fbc8",
		plivo.CallSpeakParams{
			Text: "Hello World",
		},
	)
	if err != nil {
			fmt.Print("Error", err.Error())
			return
		}
	fmt.Printf("Response: %#v\n", response)
}

Example Request

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import plivo
AUTH_ID = "Your AUTH ID"
AUTH_TOKEN = "Your AUTH TOKEN"
p = plivo.RestAPI(AUTH_ID, AUTH_TOKEN)

params = {
    # The ID of the call
    'call_uuid' : '55309cee-821d-11e4-9a73-498d468c930b',
    
    # The text you want to be played
    'text' : 'Hey, How are you?'
}

response = p.speak(params)
print str(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# encoding: utf-8
require 'plivo'
include Plivo

AUTH_ID = 'MAXXXXXXXXXXXXXXXXXX'
AUTH_TOKEN = 'MTUzZjA4NzhiYWNlOWExNTNlZGJmNzUwYWViYjc2'

p = RestAPI.new(AUTH_ID, AUTH_TOKEN)

params = {
     # The ID of the call
    'call_uuid' => '55309cee-821d-11e4-9a73-498d468c930b',
     
     # The text you want to be played
    'text' => 'Hey, How are you?'
}

response = p.speak(params)
puts response

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var plivo = require('plivo');
var p = plivo.RestAPI({
  authId: 'Your AUTH ID',
  authToken: 'Your AUTH TOKEN'
});

var params = {
    // The ID of the call
    'call_uuid' : '55309cee-821d-11e4-9a73-498d468c930b',
    'text' : 'Hey, How are you?'
}

p.speak(params, function (status, response) {
    console.log('Status: ', status);
    console.log('API Response:', response);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?php
    require 'vendor/autoload.php';
    use Plivo\RestAPI;

    $auth_id = "Your AUTH_ID";
    $auth_token = "Your AUTH_TOKEN";

    $p = new RestAPI($auth_id, $auth_token);

    $params = array(
       # The ID of the call
      'call_uuid' => '55309cee-821d-11e4-9a73-498d468c930b',
       
       # The text you want to be played
      'text' => 'Hey, How are you?'
    );

    $response = $p->speak($params);

    // Print the response
    echo "Status : ";
    print_r ($response['status']);

    echo "Response : ";
    print_r ($response['response']);
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.LinkedHashMap;
import com.plivo.helper.api.client.*;
import com.plivo.helper.api.response.response.GenericResponse;
import com.plivo.helper.exception.PlivoException;

public class PlayText {
    public static void main(String[] args) {
        String authId = "Your AUTH ID";
        String authToken = "Your AUTH TOKEN";
        RestAPI api = new RestAPI(authId, authToken, "v1" );

        LinkedHashMap<String, String> parameters = new LinkedHashMap<String, String>();
        
        // The ID of the call
        parameters.put("call_uuid", "55309cee-821d-11e4-9a73-498d468c930b");
    
        // The text you want to be played
        parameters.put("text", "Hey, How are you?");

        try {
            // Send the message
            GenericResponse msgResponse = api.speak(parameters);

            // Print the response
            System.out.println(msgResponse);
        } catch (PlivoException e) {
            System.out.println(e.getLocalizedMessage());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System;
using System.Collections.Generic;
using RestSharp;
using Plivo.API;

namespace play_text
{
    public class Program
    {
        public static void Main(string[] args)
        {
            RestAPI plivo = new RestAPI("Your AUTH_ID", "Your AUTH_TOKEN");

            IRestResponse<GenericResponse> resp = plivo.speak(new Dictionary<string, string>()
            {
                // The ID of the call
                {"call_uuid", "55309cee-821d-11e4-9a73-498d468c930b"},
            
                // The text you want to be played
                {"text", "Hey, How are you?"},
            });

            //Prints the response
            Console.Write(resp.Content);
            Console.ReadLine();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    // Example for Call Speak create
package main

import "fmt"
import "github.com/plivo/plivo-go"
 
func main() {
	client, err := plivo.NewClient("<auth_id>","<auth_token>", &plivo.ClientOptions{})
	if err != nil {
			fmt.Print("Error", err.Error())
			return
		}
	response, err := client.Calls.Speak(
		"eba53b9e-8fbd-45c1-9444-696d2172fbc8",
		plivo.CallSpeakParams{
			Text: "Hello World",
		},
	)
	if err != nil {
			fmt.Print("Error", err.Error())
			return
		}
	fmt.Printf("Response: %#v\n", response)
}

Rate this page

🥳 Thank you! It means a lot to us!