List All Endpoints

Latest Legacy

Retrieves the details of all endpoints.

API Endpoint

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

Arguments

No arguments need to be passed.

Returns

A dictionary with an objects property that contains an array of subaccount objects.

Response

HTTP Status Code: 200

{
  "api_id": "30a0c8c2-110c-11e4-bd8a-12313f016a39",
  "meta": {
    "limit": 20,
    "next": null,
    "offset": 0,
    "previous": null,
    "total_count": 11
  },
  "objects": [{
      "alias": "callme",
      "application": "/v1/Account/MA2025RK4E639VJFZAGV/Application/33406267401237901/",
      "endpoint_id": "32866729519064",
      "resource_uri": "/v1/Account/MA2025RK4E639VJFZAGV/Endpoint/32866729519064/",
      "sip_contact": "sip:callme140703093224@122.172.71.207:57563;ob",
      "sip_expires": "2022-07-21 19:26:08",
      "sip_registered": "true",
      "sip_uri": "sip:callme140703093944@phone.plivo.com",
      "sip_user_agent": "Telephone 1.1.4",
      "sub_account": null,
      "username": "callme140703093944"
    },
    {
      "alias": "polycom",
      "application": "/v1/Account/MA2025RK4E639VJFZAGV/Application/37961981447734951/",
      "endpoint_id": "17551316589618",
      "resource_uri": "/v1/Account/MA2025RK4E639VJFZAGV/Endpoint/17551316589618/",
      "sip_registered": "false",
      "sip_uri": "sip:polycom140506175228@phone.plivo.com",
      "sub_account": null,
      "username": "polycom140506175448"
    }
  ]
}

Example Request

1
2
3
4
5
import plivo

client = plivo.RestClient('<auth_id>','<auth_token>')
response = client.endpoints.list()
print(response)

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

include Plivo
include Plivo::Exceptions

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

begin
  response = api.endpoints.list
  
  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
// Example for Endpoint 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.endpoints.list(
    ).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 Endpoint list
 */
require 'vendor/autoload.php';
use Plivo\RestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new RestClient("<auth_id>","<auth_token>");

try {
    $response = $client->endpoints->list(
    );
    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
package com.plivo.api.samples.endpoint;

import java.io.IOException;
import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.endpoint.Endpoint;
import com.plivo.api.models.base.ListResponse;

/**
* Example for Endpoint list
*/
class EndpointList {
    public static void main(String [] args) {
        Plivo.init("<auth_id>","<auth_token>");
        try {
            ListResponse<Endpoint> response = Endpoint.lister()
                .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
/**
 * Example for Endpoint 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.Endpoint.List(
                );
                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
// Example for Endpoint 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.Endpoints.List(
		plivo.EndpointListParams{},
	)
	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
import plivo

auth_id = "Your AUTH_ID"
auth_token = "Your AUTH_TOKEN"
p = plivo.RestAPI(auth_id, auth_token)

# Get details of all existing endpoints
params = {
    'limit': '10', # The number of results per page
    # The number of items by which the results should be offset
    'offset': '0'
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
require 'rubygems'
require 'plivo'
include Plivo

AUTH_ID = "Your AUTH_ID"
AUTH_TOKEN = "Your AUTH_TOKEN"
p = RestAPI.new(AUTH_ID, AUTH_TOKEN)

# Get details of all existing endpoints
params = {
    'limit' => '10', # The number of results per page
    # The number of items by which the results should be offset
    'offset' => '0'
}

response = p.get_endpoints(params)
print response

# Print the total number of apps
print response[1]['meta']['total_count']

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

// Get details of all endpoints
var params = {
    'limit' : '2', // The number of results per page
    // The number of items by which the results should be offset
    'offset' : '0'
};

p.get_endpoints(params, function (status, response) {
    console.log('Status: ', status);
    console.log('API Response:\n', response);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?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);

    // Get Details of all existing Endpoints
    $params = array(
        'limit' => '10', // The number of results per page
        'offset' => '0' // The number of value items by which the results should be offset
    );
    $response = $p->get_endpoints($params);
    print_r ($response['response']); 

    // Print the total number of Endpoints
    echo "<br> Total count : ";
    echo ($response['response']['meta']['total_count']);
?>

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
package plivoexample;

import java.util.LinkedHashMap;
import com.plivo.helper.api.client.*;
import com.plivo.helper.api.response.application.ApplicationFactory;
import com.plivo.helper.exception.PlivoException;

public class App {
    public static void main(String[] args) throws IllegalAccessException {
        String auth_id = "Your AUTH_ID";
        String auth_token = "Your AUTH_TOKEN";
        RestAPI api = new RestAPI(auth_id, auth_token, "v1");

        // Get details of all existing endpoints
        LinkedHashMap<String, String> params = new LinkedHashMap<String, String>();
        params.put("limit","10"); // The number of results per page
        // The number of items by which the results should be offset
        params.put("offset","0");

        try {
            EndpointFactory resp = api.getEndpoints(params);
            System.out.println(resp);
            // Print the total number of endpoints
            System.out.println("Total count: " + resp.meta.total_count);
        } 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
26
27
28
using System;
using System.Collections.Generic;
using RestSharp;
using Plivo.API;

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

            // Get details of all existing applications
            IRestResponse<EndpointList> res = plivo.get_endpoints(new Dictionary<string, string>()
            {
                {"limit","10"}, // The number of results per page
                {"offset","0"} // The number of value items by which the results should be offset
            });

            //Prints the response
            Console.Write(res.Content);

            // Prints the total number of apps
            Console.WriteLine("Total count : " + res.Data.meta.total_count);
        }
    }
}

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
    // Example for Endpoint 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.Endpoints.List(
		plivo.EndpointListParams{},
	)
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Printf("Response: %#v\n", response)
}

Rate this page

🥳 Thank you! It means a lot to us!