Latest Legacy

Start participant-level recording

This endpoint lets you start recording for a particular participant.

API Endpoint

POST https://api.plivo.com/v1/Account/{auth_id}/MultiPartyCall/{mpc_name/UUID}/Participant/{Member_Id}/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 recording_callback_url.

  • Allowed values: GET, POST.
  • Defaults to POST.
record_track_typestring

Indicates if the recording track is at the participant level or includes all channels.

Possible values: participant / all / both

participant: Initiates single-track or participant-level recording for the provided member_id.

all: Initiates multi-channel recording for the specified participant.

both: Initiates both single-track/participant-level and all-channel recordings.

Default: all

List of events and parameters sent to the recording_callback_url

These events are generated:

  • ParticipantRecordingInitiated
  • ParticipantRecordingPaused
  • ParticipantRecordingResumed
  • ParticipantRecordingCompleted
  • ParticipantRecordingFailed

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
MemberIDstring The ID of the participant in the MPC. This ID is unique for each participant.
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_participant_recording(memberid,uuid='uuid',file_format='mp3')
print(response)

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

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

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

var plivo = require('plivo');

(function main() {
  'use strict';

  var client = new plivo.Client("<auth_id>","<auth_token>");
  client.multiPartyCalls.startParticipantRecording("memberid","mpc_uuid"/null,null/"mpc_friendlyName",
     {
        'file_format':'mp3',
     }).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
        ->startParticipantRecording("member_id", ["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.MultiPartyCallParticipantRecordingStart;
import com.plivo.api.models.multipartycall.MultiPartyCallRecordingStartResponse;
import com.plivo.api.models.multipartycall.MultiPartyCallUtils;

import java.io.IOException;

class MultiPartyCallParticipantRecordingStart {

  public static void main(String[] args) throws IOException, PlivoRestException, PlivoValidationException {
    Plivo.init("<auth_id>", "<auth_token>");

    try
    {
      MultiPartyCallRecordingStartResponse response = MultiPartyCall.participantRecordStarter("name_MPCname","member_id").update();
      System.out.println(response);
    }
    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.StartParticipantRecording(participantId: "member_id", 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/{mpc_name/UUID}/Participant/{Member_Id}/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.StartParticipantRecording(plivo.MultiPartyCallParticipantParams{FriendlyName: "MPC_Name"}, plivo.MultiPartyCallStartRecordingParams{FileFormat: "", RecordingCallbackUrl: ""})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Printf("Response: %#v\n", response)

}