List All Recordings

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

    API Endpoint

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

    Arguments

    subaccount string

    You can provide the auth_id of the subaccount in case you want to filter only recordings of a given subaccount.

    call_uuid string

    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.

    • add_time__gt: gt stands for greater than. The format expected is YYYY-MM-DD HH:MM[:ss[.uuuuuu]]. Eg:- To get all recordings that started after 2012-03-21 11:47, use add_time__gt=2012-03-21 11:47

    • add_time__gte: gte stands for greater than or equal. The format expected is YYYY-MM-DD HH:MM[:ss[.uuuuuu]]. Eg:- To get all recordings that started after or exactly at 2012-03-21 11:47[:30], use add_time__gte=2012-03-21 11:47[:30]

    • add_time__lt: lt stands for lesser than. The format expected is YYYY-MM-DD HH:MM[:ss[.uuuuuu]]. Eg:- To get all recordings that started before 2012-03-21 11:47, use add_time__lt=2012-03-21 11:47

    • add_time__lte: lte stands for lesser than or equal. The format expected is YYYY-MM-DD HH:MM[:ss[.uuuuuu]]. Eg:- To get all recordings that started before or exactly at 2012-03-21 11:47[:30], use add_time__lte=2012-03-21 11:47[:30]

    Note: The above filters can be combined to get recordings that started in a particular time range.
    limit string

    Used to display 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. Eg:- If the result contains a 1000 values and limit is set to 10 and offset is set to 705, then values 706 through 715 are 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/MAXXXXXXXXXXXXXXXXXX/Recording/?limit=3&offset=3",
        "offset": 0,
        "previous": null,
        "total_count": 948
      },
      "objects": [{
          "add_time": "2014-08-05 16:15:15.852059+05:30",
          "call_uuid": "c2c128e2-1c8c-11e4-9bff-1db8a9db0432",
          "conference_name": "noname",
          "recording_duration_ms": "345100.00000",
          "recording_end_ms": "1407235509007.00000",
          "recording_format": "mp3",
          "recording_id": "c2186400-1c8c-1124-a664-0026b945b522",
          "recording_start_ms": "1407235163907.00000",
          "recording_type": "conference",
          "recording_url": "http://s3.amazonaws.com/recordings_2013/c2186400-1c8c-1124-a664-0026b945b522.mp3",
          "resource_uri": "/v1/Account/MAXXXXXXXXXXXXXXXXXX/Recording/c2186400-1c8c-1124-a664-0026b945b522/"
        },
        {
          "add_time": "2014-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/MAXXXXXXXXXXXXXXXXXX/Recording/fc2716b0-1c8b-11e4-bwad-842b2b17453e/"
        }
      ]
    }
    

    Example Request

    1
    2
    3
    4
    5
    6
    7
    
    import plivo
    
    client = plivo.RestClient()
    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("YOUR_AUTH_ID", "YOUR_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';
        
        // 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.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("YOUR_AUTH_ID", "YOUR_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();
            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("YOUR_AUTH_ID", "YOUR_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
    
    curl -i --user AUTH_ID:AUTH_TOKEN \
        https://api.plivo.com/v1/Account/{auth_id}/Recording/
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    
    // Example for Recording list
    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.Recordings.List(
    		plivo.RecordingListParams{
    			Offset: 0,
    			Limit: 5,
    		},
    	)
    	if err != nil {
    		panic(err)
    	}
    	fmt.Printf("Response: %#v\n", response)
    }