Latest Legacy

Warm transfer a caller

A user (U1) can transfer a call with a member (U2) of a multiparty call to another user (U3). With a warm transfer, the user who initiates the transfer (U1) and the user to whom the call is transferred to (U3) can speak privately before U2 is added to the call.

API Endpoint

POST https://phlorunner.plivo.com/v1/phlo/{phlo_id}/multi_party_call/{node_id}

Arguments

URL Params

Param Description/Allowed Values
phlo_idRequiredstring

Unique identifier of a PHLO. PHLO IDs are listed on the PHLO page of the console.

node_idRequiredstring

Unique identifier of the node. The ID is available in the configuration section of the corresponding multiparty call node in the PHLO.

Payload

Param Description/Allowed Values
actionRequired

Value is always warm_transfer.

toRequired

Phone number or SIP endpoint address of the user to which the call is to be transferred.

roleRequired

Role of the user added to the multiparty call.

Allowed values: customer, agent
Defaults to agent.

trigger_sourceRequired

Phone number or SIP endpoint address of the user initiating the transfer.

Returns

Returns a MultiPartyCall object.

Response

HTTP Status Code: 201

{
    "api_id": "faad0293-f5f0-487e-8ff7-b45ba6c45b25",
    "error": ""
}

Example Request

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import plivo

auth_id = '<auth_id>'
auth_token = '<auth_token>'
phlo_id = '<phlo_id>'
node_id = '<node_id>'
phlo_client = plivo.phlo.RestClient(auth_id=auth_id, auth_token=auth_token)
phlo = phlo_client.phlo.get(phlo_id)

trigger_source = '<member_address>'
to = '<target_address>'

response = phlo.multi_party_call(node_id).warm_transfer(trigger_source, to)
print (str(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
require 'rubygems'
require 'plivo'

include Plivo

AUTH_ID = '<auth_id>'
AUTH_TOKEN = '<auth_token>'

client = Phlo.new(AUTH_ID, AUTH_TOKEN)

# if credentials are stored in the PLIVO_AUTH_ID and the PLIVO_AUTH_TOKEN environment variables
# then initialize client as:
# client = Phlo.new

# provide the phlo_id in params
phlo = client.phlo.get('<phlo_id>')

# multi_party_call.warm_transfer(<trigger_source>, <to>)

begin
    response = multi_party_call.warm_transfer('<member_address>', '<target_address>')
    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
19
var plivo = require('plivo');
var PhloClient = plivo.PhloClient;

var authId = '<auth_id>';
var authToken = '<auth_token>';
var phloId = '<phlo_id>';
var mpcId = '<node_id>';
var phloClient = phlo = null;
var mpcSourceNo = '<member_address>';
var mpcTargetNo = '<target_address>';
var role = 'agent';

// Warm Transfer - multi party call
phloClient = new PhloClient(authId, authToken);
phloClient.phlo(phloId).multiPartyCall(mpcId).warmTransfer(mpcSourceNo, mpcTargetNo, role).then(function (result) {
    console.log('Warm transfer result', result);
}).catch(function (err) {
    console.log('Warm transfer failed', err);
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
/**
 * Example for Multiparty warm transfer
 */
require 'vendor/autoload.php';
use Plivo\Resources\PHLO\PhloRestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new PhloRestClient("<auth_id>", "<auth_token>");
$phlo = $client->phlo->get("<phlo_id>");
$multiPartyCall = $phlo->multiPartyCall()->get("<node_id>");
try {
    $response = $multiPartyCall->warm_transfer($trigger_source, $to, $role);
    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
25
26
27
28
29
30
import com.plivo.api.Plivo;
import com.plivo.api.PlivoClient;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.node.MultiPartyCall;
import com.plivo.api.models.node.MultiPartyCallActionType;
import com.plivo.api.models.node.MultiPartyCallUpdateResponse;
import com.plivo.api.models.phlo.Phlo;
import java.io.IOException;

public class Example
{
    privatestatic final  String authId = "<auth_id>";
    private static final String authToken = "<auth_token>";
    private static PlivoClient client = new PlivoClient(authId, authToken);
    public static void main(String[] args) throws IOException, PlivoRestException
    {
        String phloId = "<phlo_id>";
        String nodeId = "<node_id>";
        String triggerSource = "<member_address>";
        String to = "<target_address>";
        String memberId = to;
        String role = "agent";
        Plivo.init(authId, authToken);
        Phlo phlo = Phlo.getter(phloId).client(client).get();

        MultiPartyCall mpc = MultiPartyCall.getter(phloId, nodeId).get();

        MultiPartyCallUpdateResponse response = MultiPartyCall.updater(phloId, nodeId).triggerSource(triggerSource).to(to).role(role).warm_transfer().update();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using System;
using Plivo;

namespace test_PHLO_dotnet
{
    class Program
    {
        public static void Main(string[] args)
        {
            var phloClient = new PhloApi("<auth_id>", "<auth_token>");
            var phloID = "<phlo_id>";
            var nodeID = "<node_id>";
            var phlo = phloClient.Phlo.Get(phloID);
            var multiPartyCallObj = phlo.MultiPartyCall("nodeID");

            var triggerSource = "<member_address>";
            var to = "<target_address>";
            var role = "agent";

            Console.WriteLine(multiPartyCallObj.WarmTransfer(triggerSource, to));
        }
    }
}
1
2
3
4
5
curl --request POST \
  --user AUTH_ID:AUTH_TOKEN \
  --url 'https://phlorunner.plivo.com/v1/phlo/{phlo_id}/multi_party_call/{node_id}' \
  --header 'Content-Type: application/json' \
  --data '{"action": "warm_transfer","trigger_source": "12025550000","role": "agent","to":"12025551111"}'
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package main

import (
	"fmt"
	"plivo-go"
)

// Initialize the following params with corresponding values to trigger resources

const authId  = "<auth_id>"
const authToken = "<auth_token>"
const phloId = "<phlo_id>"
const nodeId = "<node_id>"
const actionTo = "<member_address>"
const actionSource = "<target_address>"

//Use the following multiparty call actions as needed; do not edit the following

const actionRole = "agent"
const actionCall = "call"
const actionWarmTransfer = "warm_tranfer"
const actionColdTransfer = "cold_transfer"

func main() {
	testMultiPartyCallWarmTransfer()
}

func testMultiPartyCallWarmTransfer() {
	phloClient,err := plivo.NewPhloClient(authId, authToken, &plivo.ClientOptions{})
	if err != nil {
			fmt.Print("Error", err.Error())
			return
		}
	phloGet, err := phloClient.Phlos.Get(phloId)
	if err != nil {
			fmt.Print("Error", err.Error())
			return
		}
	MPCGet, err := phloGet.MultiPartyCall(nodeId)
	if err != nil {
			fmt.Print("Error", err.Error())
			return
		}
	callPayload := plivo.PhloMultiPartyCallActionPayload{
		actionWarmTransfer,
		actionTo,
		actionRole,
		actionSource,
	}
	response, err := MPCGet.WarmTransfer(callPayload)
	if err != nil {
			fmt.Print("Error", err.Error())
			return
		}
	fmt.Printf("Response: %#v\n", response)
}