Start Recording a Conference
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: Transcription is completely automated; turnaround time is about 30 minutes. Transcriptions are charged and details are available in pricing page |
Note: Currently, the service is only available in English, and you will be charged for the usage. Our transcription service is limited to calls with a duration greater than 500ms and lesser than 4-hour with a recording file size smaller than 2GB. | |
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 |
List of parameters sent to transcriptionUrl
transcription_charge | The credit deducted for the transcription. |
transcription | The transcribed text of the recording. |
duration | The duration in seconds of the recording. |
call_uuid | The call UUID of the call which was transcribed. |
transcription_rate | The rate of the transcription per minute. |
recording_id | Recording ID of the recording which was transcribed. |
error | can be Recording duration too long for transcription or Recording file size too large for transcription. Empty if transcription is successful. |
Note: .mp3 files are smaller in size than .wav files. Consider changing the recording file format to mp3 to avoid this error. |
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)
}