Start Recording a Conference

Latest Legacy

This API lets you start recording an ongoing conference. You can start recording the conference by using this API after the conference has been initiated. Alternatively you can also use the recording capabilities in Conference XML to record the conference

API Endpoint

POST https://api.plivo.com/v1/Account/{auth_id}/Conference/{conference_name}/Record/

Attributes

file_format optional	The file format in which the recording needs to be saved. This can either be mp3 or wav. Defaults to mp3 format.
transcription_type optional	auto: This transcription is completely automated and the turnaround time is 5 minutes. Transcriptions are charged and details are available in pricing page
Deprecation Notice - Hybrid Transcriptions: Starting September 7th, 2020, Plivo’s transcription service will no longer support Hybrid (human-reviewed) transcriptions. Transcription requests with the Transcription Type attribute set to Hybrid will be processed, but will not undergo human review. All transcriptions will be billed as per the standard rate for automated (non-hybrid) transcriptions.
Note: Currently we support transcriptions only for voice mail use case (calls less than 60 second duration).
transcription_url optional	The URL to which the transcription needs to be posted.
transcription_method optional	The HTTP verb that is used to invoke the transcription_url. Defaults to POST.
callback_url optional	The URL which is invoked when the recording ends. This URL will be invoked with the parameters mentioned in the “Callback URL parameters” section below
callback_method optional	The HTTP verb that needs to be used to invoke the callback_url. Defaults to POST

List of parameters sent to callback_url

api_id	The API ID that was returned by the conference record API
record_url	The URL from which the recorded file can be accessed
recording_id	The recording ID associated with the recording file
conference_name	The name of the conference recorded
recording_duration	The duration of the recording in seconds
recording_duration_ms	The duration of the recording in milliseconds
recording_start_ms	The start time of the recording since epoch in milliseconds
recording_end_ms	The end time of the recording since epoch in milliseconds

Returns

Returns an acknowledgement that conference recording has started and provides the URL in which it can be accessed.

Response

HTTP Status Code: 202

{
	"api_id": "2867b6e2-58c3-11e1-86da-adf28403fe48",
	"message": "conference recording started",
	"recording_id": "93bc7c6a-3b2b-11e3",
	"url": "http://s3.amazonaws.com/recordings_2013/93bc7c6a-3b2b-11e3.mp3",
}

Example Request

1
2
3
4
5
6
import plivo

client = plivo.RestClient()
response = client.conferences.record(
    conference_name='testing', )
print(response)

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

include Plivo
include Plivo::Exceptions

api = RestClient.new("YOUR_AUTH_ID", "YOUR_AUTH_TOKEN")

begin
  response = api.conferences.record(
    'my conf'
  )
  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
// Example for Conference Record create

var plivo = require('plivo');

(function main() {
    'use strict';
    
    // As the auth_id and auth_token are unspecified, Plivo will fetch them from the PLIVO_AUTH_ID and PLIVO_AUTH_TOKEN environment variables.
    var client = new plivo.Client();
    client.conferences.record(
        "My Conf Room", // conference 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
<?php
/**
 * Example for Conference record create
 */
require 'vendor/autoload.php';
use Plivo\RestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new RestClient("YOUR_AUTH_ID", "YOUR_AUTH_TOKEN");
try {
    $response = $client->conferences->startRecording(
        'My conference'
    );
    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
package com.plivo.api.samples.conference.record;

import java.io.IOException;

import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.conference.Conference;
import com.plivo.api.models.conference.ConferenceRecordCreateResponse;

/**
 * Example for Conference Record create
 */
class RecordCreate {
    public static void main(String [] args) {
        Plivo.init();
        try {
            ConferenceRecordCreateResponse response = Conference.recorder("My Conf Room")
                    .record();

            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
/**
 * Example for Record 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("YOUR_AUTH_ID", "YOUR_AUTH_TOKEN");
            try
            {
                var response = api.Conference.StartRecording(
                    "conf 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}/Conference/{conference_name}/Record/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Example for Conference Record create
package main

import "fmt"
import "github.com/plivo/plivo-go"

func main() {
	client, err := plivo.NewClient("", "", &plivo.ClientOptions{})
	if err != nil {
		panic(err)
	}
	response, err := client.Conferences.Record(
		"My Conf Room",
		plivo.ConferenceRecordParams{},
	)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Response: %#v\n", response)
}

Example Request

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

params = {
    # Name of your Conference
    'conference_name' : 'my_conference_name'
}

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

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

AUTH_ID = 'MAXXXXXXXXXXXXXXXXXX'
AUTH_TOKEN = 'MTUzZjA4NzhiYWNlOWExNTNlZGJmNzUwYWViYjc2'

p = RestAPI.new(AUTH_ID, AUTH_TOKEN)

params = {
    # Name of your Conference
    'conference_name' => 'my_conference_name'
}

response = p.record_conference(params)
puts response

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

var params = {
    // Name of the Conference
    'conference_name' : 'my_conference_name'
}

p.record_conference(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
<?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(
      # Name of your Conference
      'conference_name' => 'my_conference_name'
    );

    $response = $p->record_conference($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
import java.util.LinkedHashMap;
import com.plivo.helper.api.client.*;
import com.plivo.helper.api.response.response.Record;
import com.plivo.helper.exception.PlivoException;

public class StartRecordingConf {
    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>();
        
        // Name of your Conference
        parameters.put("conference_name", "my_conference_name");

        try {
            // Send the message
            Record msgResponse = api.recordConference(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
using System;
using System.Collections.Generic;
using RestSharp;
using Plivo.API;

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

            IRestResponse<Record> resp = plivo.record_conference(new Dictionary<string, string>()
            {
                // Name of your Conference
                {"conference_name", "my_conference_name"},
            });

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

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}/Conference/{conference_name}/Record/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    // Example for Conference Record create
package main

import "fmt"
import "github.com/plivo/plivo-go"

func main() {
	client, err := plivo.NewClient("", "", &plivo.ClientOptions{})
	if err != nil {
		panic(err)
	}
	response, err := client.Conferences.Record(
		"My Conf Room",
		plivo.ConferenceRecordParams{},
	)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Response: %#v\n", response)
}

Rate this page

🥳 Thank you! It means a lot to us!