List All Recordings

Latest Legacy

This method lists the recordings that are available in your account.

API Endpoint

GET https://api.plivo.com/v1/Account/{auth_id}/Recording/

Arguments

from_numberstring	Provide a source phone number (E.164 format) or SIP endpoint to retrieve recordings that match the number.
to_numberstring	Provide a destination phone number (E.164 format) or SIP endpoint to retrieve recordings that match the number.
subaccount string	Provide the auth_id of a subaccount if you want to filter only recordings for a given subaccount.
call_uuid string	Use the call_uuid of the call to filter only recordings associated with a specific call.
add_time string	Filter recordings based on the time they were added. The time format expected is YYYY-MM-DD HH:MM[:ss[.uuuuuu]]. add_time__gt: gt stands for greater than. For example, to get all recordings that started after 2021-03-21 11:47, use add_time__gt=2021-03-21 11:47 add_time__gte: gte stands for greater than or equal. To get all recordings that started after or exactly at 2021-03-21 11:47[:30], use add_time__gte=2021-03-21 11:47[:30] add_time__lt: lt stands for less than. To get all recordings that started before 2021-03-21 11:47, use add_time__lt=2021-03-21 11:47 add_time__lte: lte stands for less than or equal to. To get all recordings that started before or exactly at 2021-03-21 11:47[:30], use add_time__lte=2021-03-21 11:47[:30]
Note: You can combine these filters to get recordings that were added during a particular time range. If you don’t use the add_time filter when you search, Plivo uses a search window of the last seven days from the current date. The add_time parameter permits Plivo users to obtain recordings within a 30-day search boundary limit, while still providing unrestricted access to older recordings. Alternatively, you can use add_time__[lt\|lte] and add_time__[gt\|gte] to search within a specific time range. If the provided time range exceeds the 30-day search boundary, the API will return a 400 response code, signaling an error. Timestamp values need to be specified as UTC.
mpc_namestring	Filtering based on Name of the MPC in case the recording file belongs to an MPC.
mpc_uuidstring	Provide a multiparty call UUID to retrieve recordings that match that UUID.
conference_namestring	Provide a conference name to retrieve recordings that match that name.
conference_uuidstring	Provide a conference UUID to retrieve recordings that match that UUID.

Note: You can combine these filters to get recordings that started within a particular time range.

limit string	Denotes the number of results per page. The maximum number of results that can be fetched is 20.
offset string	Denotes the number of value items by which the results should be offset. For example, if the result contains 1,000 values,limit is set to 10, and offset is set to 705, then values 706 through 715 will be displayed in the results. This parameter is also used for pagination of the results.

Returns

Returns the details of the recordings based on the filters specified in the API.

Response

HTTP Status Code: 200

{
  "api_id": "ff25223a-1c9f-11e4-80aa-12313f048015",
  "meta": {
    "limit": 3,
    "next": "/v1/Account/MA2025RK4E639VJFZAGV/Recording/?limit=3&offset=3",
    "offset": 0,
    "previous": null,
    "total_count": 948
  },
  "objects": [{
      "add_time": "2022-08-05 16:15:15.852059+05:30",
      "call_uuid": "c2c128e2-1c8c-11e4-9bff-1db8a9db0432",
      "conference_name": "noname",
      "recording_duration_ms": "345100.00000", // The duration of the recording in milliseconds
      "recording_end_ms": "1407235509007.00000", // The end time of the recording since epoch in milliseconds
      "recording_format": "mp3",
      "recording_id": "c2186400-1c8c-1124-a664-0026b945b522",
      "recording_start_ms": "1407235163907.00000", // The start time of the recording since epoch in milliseconds
      "recording_type": "conference",
      "recording_url": "http://s3.amazonaws.com/recordings_2013/c2186400-1c8c-1124-a664-0026b945b522.mp3",
      "resource_uri": "/v1/Account/MA2025RK4E639VJFZAGV/Recording/c2186400-1c8c-1124-a664-0026b945b522/"
    },
    {
      "add_time": "2022-08-05 16:05:21.993853+05:30",
      "call_uuid": "fc773e88-1c8b-11e4-b25a-0fe7bcc54670",
      "conference_name": "noname",
      "recording_duration_ms": "90700.00000",
      "recording_end_ms": "1407234920253.00000",
      "recording_format": "mp3",
      "recording_id": "fc2716b0-1c8b-11e4-bwad-842b2b17453e",
      "recording_start_ms": "1407234829553.00000",
      "recording_type": "conference",
      "recording_url": "http://s3.amazonaws.com/recordings_2013/fc2716b0-1c8b-11e4-bwad-842b2b17453e.mp3",
      "resource_uri": "/v1/Account/MA2025RK4E639VJFZAGV/Recording/fc2716b0-1c8b-11e4-bwad-842b2b17453e/"
    }
  ]
}

Example Request

1
2
3
4
5
6
7
import plivo

client = plivo.RestClient('<auth_id>','<auth_token>')
response = client.recordings.list(
    offset=0,
    limit=5, )
print(response)

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

include Plivo
include Plivo::Exceptions

api = RestClient.new("<auth_id>","<auth_token>")

begin
  response = api.recordings.list(
    limit: 5,
    offset: 0
  )
  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
19
20
// Example for Recording list

var plivo = require('plivo');

(function main() {
    'use strict';
    
   // If auth id and auth token are not specified, Plivo will fetch them from the environment variables.
    var client = new plivo.Client("<auth_id>","<auth_token>");
    client.recordings.list(
        {
            offset: 0,
            limit: 5,
        },
    ).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
19
20
21
<?php
/**
 * Example for Recording list
 */
require 'vendor/autoload.php';
use Plivo\RestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new RestClient("<auth_id>","<auth_token>");

try {
    $response = $client->recordings->list(
        [
        	'limit' => 2,
        	'offset' => 2
        ]
    );
    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
package com.plivo.api.samples.recording;

import java.io.IOException;
import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.recording.Recording;
import com.plivo.api.models.base.ListResponse;

/**
* Example for Recording list
*/
class RecordingList {
    public static void main(String [] args) {
        Plivo.init("<auth_id>","<auth_token>");
        try {
            ListResponse<Recording> response = Recording.lister()
                .offset(0)
                .limit(5)
                .list();

            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
30
/**
 * Example for Recording List
 */
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("<auth_id>","<auth_token>");
            try
            {
                var response = api.Recording.List(
                    limit:5,
                    offset:0
                );
                Console.WriteLine(response);
            }
            catch (PlivoRestException e)
            {
                Console.WriteLine("Exception: " + e.Message);
            }
        }
    }
}

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
// Example for Recording list
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.Recordings.List(
		plivo.RecordingListParams{
			Offset: 0,
			Limit:  5,
		},
	)
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Printf("Response: %#v\n", response)
}

Example Request

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import plivo
auth_id = "Your AUTH ID"
auth_token = "Your AUTH TOKEN"
p = plivo.RestAPI(auth_id, auth_token)

params = {
    # All these params are optional

    # Auth Id of the subaccount
    'subaccount' : 'sub_auth_id',
    'call_uuid' : 'c2c128e2-1c8c-11e4-9bff-1db8a9db0432'

    # Refer to Arguments of Recording API for more parameters
}

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

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

AUTH_ID = 'MAXXXXXXXXXXXXXXXXXX'
AUTH_TOKEN = 'MTUzZjA4NzhiYWNlOWExNTNlZGJmNzUwYWViYjc2'

p = RestAPI.new(AUTH_ID, AUTH_TOKEN)

params = {
    # All these params are optional

    # Auth Id of the subaccount
    'subaccount' => 'sub_auth_id',
    'call_uuid' => 'c2c128e2-1c8c-11e4-9bff-1db8a9db0432'

    # Refer to Arguments of Recording API for more parameters
}

response = p.get_recordings(params)
puts response

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

var params = {
    // All these params are optional

    // Auth Id of the subaccount
    'subaccount' : 'sub_auth_id',
    'call_uuid' : 'c2c128e2-1c8c-11e4-9bff-1db8a9db0432'

    // Refer to Arguments of Recording API for more parameters
}

p.get_recordings(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
24
25
26
27
28
<?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(
      # All these params are optional
  
      # Auth Id of the subaccount
      'subaccount' => 'sub_auth_id',
      'call_uuid' => 'c2c128e2-1c8c-11e4-9bff-1db8a9db0432'
  
      # Refer to Arguments of Recording API for more parameters
    );

    $response = $p->get_recordings($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
28
29
30
31
32
// import java.util.LinkedHashMap;
// import com.plivo.helper.api.client.*;
// import com.plivo.helper.api.response.response.GenericResponse;
// import com.plivo.helper.exception.PlivoException;
//
// public class GetAllRecordings {
//     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>();
//
//         // All these params are optional
//
//         // Auth Id of the subaccount
//         parameters.put("subaccount", "sub_auth_id");
//         parameters.put("call_uuid", "c2c128e2-1c8c-11e4-9bff-1db8a9db0432");
//
//         // Refer to Arguments of Recording API for more parameters
//
//         try {
//             // Send the message
//             GenericResponse msgResponse = api.getRecordings(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
using System;
using System.Collections.Generic;
using RestSharp;
using Plivo.API;

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

            IRestResponse<RecordingList> resp = plivo.get_recordings();

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

Rate this page

🥳 Thank you! It means a lot to us!