Latest Legacy

Start Recording a Multiparty Call

This endpoint starts recording a Multiparty Call.

API Endpoint

POST https://api.plivo.com/v1/Account/{auth_id}/MultiPartyCall/name_{mpc_name}/Record/

Arguments

file_format

Format of the recording.

  • Allowed values: mp3, wav.
  • Defaults to mp3.
recording_callback_url URL to which status update events for this recording should be posted.
recording_callback_method

HTTP verb used to invoke the URL configured as status_callback_url.

  • Allowed values: GET, POST.
  • Defaults to POST.
Note: A Supervisor’s voice will be recorded regardless of the coach_mode setting.

List of events and parameters sent to the recording_callback_url

These events are generated:

  • MPCRecordingInitiated
  • MPCRecordingPaused
  • MPCRecordingResumed
  • MPCRecordingCompleted
  • MPCRecordingFailed

This information is sent to the URL when an event is triggered:

EventNamestring Event that triggered this notification. This parameter will have one of the values from the list of events above.
EventTimestampstring Timestamp at which the event occurred.

Format: YYYY-MM-DD HH:mm:ss+|-hh:mm
MPCNamestring Friendly name provided during the creation of the MPC.
MPCUUIDstring Unique ID of the Multiparty call.
RecordingDurationstring Duration of recording in seconds.
RecordingEndTimestring Timestamp at which the recording ended.

Format: YYYY-MM-DD HH:mm:ss+|-hh:mm
RecordingFormatstring Format of the recording.
RecordingResourceURLstring Resource URL of the recording file. You can use this URL to fetch the recording details later.
RecordingStartTimestring Timestamp at which the recording started.

Format: YYYY-MM-DD HH:mm:ss+|-hh:mm
RecordingURLstring Complete path to the recorded file URL.
RecordingUUIDstring Unique identifier to identify the file.
SequenceNumberstring Indicates the sequence of the callback. Helpful to sort the callback events posted to the recording_callback_url.

Returns

If successful, this endpoint returns an acknowledgement that the recording has started, along with a URL to access the recording.

Response

{
  "api_id": "e05b5263-45dc-11eb-9014-0242ac110003",
  "message": "MPC: test_mpc_1 record started",
  "recording_id": "e06ac332-45dc-11eb-94fe-06dd7f581a50",
  "recording_url": "https://media.plivo.com/v1/Account/MAOTE1OWE0MDK0MTLHYW/Recording/e06ac332-45dc-11eb-94fe-06dd7f581a50.mp3"
}

Example Request 

1
2
3
4
5
6

import plivo

client = plivo.RestClient(auth_id="<auth_id>", auth_token="<auth_token>")

response = client.multi_party_calls.start_recording(friendly_name='mpc_name', file_format='wav', recording_callback_url='https://plivo.com/status')
print(response)

1
2
3
4
5
6
7
8
9
10
11
12

require 'rubygems'
require 'plivo'
include Plivo
include Plivo::Exceptions

api = RestClient.new("<auth_id>","<auth_token>")
begin
  response = api.multipartycalls.start_recording("friendly_name":"mpc_name")
  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

var plivo = require('plivo');

(function main() {
    'use strict';

    var client = new plivo.Client("<auth_id>","<auth_token>");
    client.multiPartyCalls.startRecording(
        {
            'file_format':'wav',
            'recordingCallbackUrl':'https://plivo.com/status'
            
        }, 
        'mpc_name').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

<?php
require 'vendor/autoload.php';

use Plivo\RestClient;
use Plivo\Exceptions\PlivoRestException;

$client = new RestClient("<auth_id>", "<auth_token>");
try
{
    $response = $client
        ->multiPartyCalls
        ->startRecording(["friendly_name" => "mpc_name", ]);
    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

package com.plivo.examples.multipartycall;

import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.exceptions.PlivoValidationException;
import com.plivo.api.models.multipartycall.MultiPartyCall;
import com.plivo.api.models.multipartycall.MultiPartyCallRecordingStart;
import com.plivo.api.models.multipartycall.MultiPartyCallRecordingStartResponse;
import com.plivo.api.models.multipartycall.MultiPartyCallUtils;

import java.io.IOException;

public class StartMPCRecording {

  public static void main(String[] args) throws IOException, PlivoRestException, PlivoValidationException {
    Plivo.init("<auth_id>", "<auth_token>");
    try{
      MultiPartyCallRecordingStart recordingStart1 = MultiPartyCall.recordStarter(MultiPartyCallUtils.friendlyName("myMPC1"));
      MultiPartyCallRecordingStartResponse resp1 = recordingStart1.fileFormat("wav").recordingCallbackUrl("https://<yourdomain.com>/status/recording/").update();
      System.out.println(resp1.getRecordingUrl());
      System.out.println(resp1.getRecordingId());
    }
    catch (Exception 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

using System;
using Plivo;
using Plivo.Exception;

namespace PlivoExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            var api = new PlivoApi("<auth_id>", "<auth_token>");

            try
            {
                var response = api.MultiPartyCall.StartRecording(friendlyName: "mpc_name");
                Console.WriteLine(response);
            }
            catch (PlivoRestException e)
            {
                Console.WriteLine("Exception: " + e.Message);
            }

        }
    }
}

1
2
3
4

curl -i --user AUTH_ID:AUTH_TOKEN \
    -H "Content-Type: application/json" \
    -d '{"file_format": "mp3"}' \                     
    https://api.plivo.com/v1/Account/{auth_id}/MultiPartyCall/name_{mpc_name}/Record/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import (
	"fmt"

	"github.com/plivo/plivo-go/v7"
)

func main() {
	client, err := plivo.NewClient("<auth_id>", "<auth_token>", &plivo.ClientOptions{})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	response, err := client.MultiPartyCall.StartRecording(plivo.MultiPartyCallBasicParams{FriendlyName: "MPC_Name"}, plivo.MultiPartyCallStartRecordingParams{FileFormat: "", RecordingCallbackUrl: ""})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Printf("Response: %#v\n", response)

}