Get Details of a Single Application

Latest Legacy

Get Details of a Single Application

Get details of an particular application by passing the app_id. This API returns all the information linked with the application.

API Endpoint

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

Arguments

No arguments need to be passed.

Returns

Returns an Application object.

Response

HTTP Status Code:200

{
  "answer_method": "GET",
  "answer_url": "http://webapp.com/dial.xml",
  "app_id": "20372631212782780",
  "app_name": "Dial Office",
  "default_app": false,
  "enabled": true,
  "fallback_answer_url": "",
  "fallback_method": "POST",
  "hangup_method": "POST",
  "hangup_url": "http://webapp.com/dial.xml",
  "message_method": "POST",
  "message_url": "",
  "public_uri": false,
  "resource_uri": "/v1/Account/MAXXXXXXXXXXXXXXXXXX/Application/20372631212782780/",
  "sip_uri": "sip:20372631212782780@app.plivo.com",
  "sub_account": null,
  "log_incoming_messages": true
}

Example Request

1
2
3
4
5
6
import plivo

client = plivo.RestClient('<auth_id>','<auth_token>')
response = client.applications.get(
    app_id='24075895272788587', )
print(response)

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

include Plivo
include Plivo::Exceptions

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

begin
  response = api.applications.get(
    '15784735442685051'
  )
  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 Application get

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.applications.get(
        "15784735442685051", // app id
    ).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
<?php
/**
 * Example for Application get
 */
require 'vendor/autoload.php';
use Plivo\RestClient;
use Plivo\Exceptions\PlivoRestException;
$client = new RestClient("<auth_id>","<auth_token>");

try {
    $response = $client->applications->get(
        '1101234567899201'
    );
    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.application;

import java.io.IOException;
import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.application.Application;
import com.plivo.api.models.application.Application;

/**
* Example for Application get
*/
class ApplicationGet {
    public static void main(String [] args) {
        Plivo.init("<auth_id>","<auth_token>");
        try {
            Application response = Application.getter("15784735442685051")
                .get();

            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 Application Get
 */
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.Application.Get(
                    appId:"15784735442685051"
                );
                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
// Example for Application get
package main

import "fmt"
import "github.com/plivo/plivo-go"
 
func main() {
	client, err := plivo.NewClient("<auth_id>","<auth_token>", &plivo.ClientOptions{})
	if err != nil {
		panic(err)
	}
	response, err := client.Applications.Get(
		"15784735442685051",
	)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Response: %#v\n", response)
}

Example Request

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import plivo

auth_id = "Your_AUTH_ID"
auth_token = "Your_AUTH_TOKEN"
p = plivo.RestAPI(auth_id, auth_token)

# Get details of a single application
params = {
    # Application ID for which to retrieve details
    'app_id': '16631550192125875'
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 a single application
params = {
    # Application ID for which to retrieve details
    'app_id' => '16631550192125875'
}

response = p.get_application(params)
puts response

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var plivo = require('plivo');
var p = plivo.RestAPI({
  authId: 'Your_AUTH_ID',
  authToken: 'Your_AUTH_TOKEN'
});

var params = {
    // Application ID for which to retrieve details
    'app_id': '16631550192125875'
};
p.get_application(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
<?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 Single Application
    $params = array(
        # Application ID for which to retrieve details
        'app_id' => '16631550192125875'
    );
    $response = $p->get_application($params);
    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
package plivoexample;

import java.util.LinkedHashMap;
import com.plivo.helper.api.client.*;
import com.plivo.helper.api.response.application.Application;
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 a single application
        LinkedHashMap<String, String> params = new LinkedHashMap<String, String>();
        // Application ID for which to retrieve details
        params.put("app_id","16631550192125875");

        try {
            Application resp = api.getApplication(params);
            System.out.println(resp);
        } 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
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 a single application
            IRestResponse<Application> res1 = plivo.get_application(new Dictionary<string, string>()
            {
                {"app_id","16631550192125875"} // Application ID for which to retrieve details
            });

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    // Example for Application get
package main

import "fmt"
import "github.com/plivo/plivo-go"
 
func main() {
	client, err := plivo.NewClient("<auth_id>","<auth_token>", &plivo.ClientOptions{})
	if err != nil {
		panic(err)
	}
	response, err := client.Applications.Get(
		"15784735442685051",
	)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Response: %#v\n", response)
}

Rate this page

🥳 Thank you! It means a lot to us!