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

    There are two types of transcriptions: ‘auto’ and ‘hybrid’

    • ‘auto’: This transcription is completely automated and the turnaround time is 5 minutes.

    • ‘hybrid’: This type of transcription is partially automated and manually reviewed. The turnaround time is 15 minutes.

    Both types of transcriptions are charged and details are available in pricing page.

    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)
    }