Warning: make sure that you have read through the Plivo Web SDK Quick-Start Guide and the Make Outgoing Calls Tutorial before you start this tutorial.


Create Dynamic SIP Endpoints

The ability to create dynamic SIP endpoints is useful in use cases where each call connection needs to be unique and non-replicable. This can prevent uninvited callers from calling in on an existing line. When dynamic SIP endpoints are enabled, the following sequence of events will occur:

  1. The caller loads the URL into a browser and clicks "Allow" to enable the computer microphone for the app.
  2. The caller clicks "login" to login automatically with a newly created SIP Endpoint credential. This occurs because the app is sending a HTTP request to the Endpoint API when the "login" button is clicked. Then newly created endpoint credentials is then passed to app (e.g., phone.py for Python) and the user is automatically logged in.
  3. Then the caller enters the destination phone number (e.g., 14153336666) in the text field and clicks 'Call'.
  4. The call status will indicate the stage of the call (e.g., "Ready", "Connecting", "Ringing", and "Call Answered"). Once the call is answered, the caller may click "End" to hang up the call.
  5. When the call is hung up, and the user clicks "logout", the endpoint is deleted.


Below are the steps and the code snippet to set up 2 routes on your webserver, one for creating the endpoint and theother for deleting it.

Warning: make sure that you have read through the Plivo Web SDK Quick-Start Guide and have all of the Pre-requisites before you start this tutorial.

Step 1: Create a Plivo Application

First, we must configure the Plivo application and link it to the direct-dial app that you set up during the Web SDK Quick Start Guide. If you're using the default "Direct Dial" app that's provided in your Plivo account, or have completed the Make Outgoing Calls tutorial, you may skip this step and go directly to "Create a SIP Endpoint". If you've set up a route on your own web server, then follow the steps below to configure your Plivo application:

Note: you may skip this step if you've already gone through these steps in the Make Outgoing Calls tutorial.
  1. Create a Plivo Application by visiting the Application Page in your Plivo GUI and click on New Application or by using Plivo's Application API.
  2. Give your application a name.
  3. Enter your server URL with your caller ID appended (e.g., http://www.example.com/direct-dial/?DialMusic=real&CLID=14152223333) in the Answer URL and Hangup URL fields.
  4. Set both methods as POST.
  5. Click on Create to save your application.
  6. Advanced Hack: you can also create, edit, and delete Plivo Applications through the Application API.
Plivo Create Direct Dial Application

Step 2: Assign a Plivo number to your app

  1. Navigate to the Numbers page and select the phone number you want to use for this app.
  2. Note: If you don’t yet have a Plivo number, go to the Buy Numbers page to purchase a Plivo phone number or read the Search and Buy Phone Numbers Guide for complete details.
  3. Select the name of your app from the Plivo App dropdown list.
  4. Click on Update to save.
Assign Phone Number to Receive Incoming Call App

Step 3: Create a SIP Endpoint

  1. Create a Plivo SIP Endpoint by visiting the Endpoint Page in your Plivo GUI and click on New Endpoint or by using Plivo's Endpoint API.
  2. Choose a username, password, and alias for your SIP endpoint. You will use the username and password to login to the webapp that you will build in the following steps.
  3. Link this SIP Endpoint to your server application by selecting it in the Application drop down. Select Direct Dial if you're using the default Plivo application. Or select the name of the application you set up in the first step (i.e., Create an Application section) of this tutorial.
Plivo Create SIP Endpoint

Step 4: Build the App

Select the language you would like to use for your app.


Download the asset files
To build the web app, we first need all the static assets that will be supporting your web app (e.g., CSS, JavaScript, images, etc).
1. Create a "static" folder in the root directory of your app.
2. Download assets.zip and save it in the "static" folder that you just created (e.g., the location of the jquery.js file will be "static/jquery.js"). See line 7 of the make_outgoing.html file below for reference.
3. Serve up the asset files either directly through the web server or by using a content delivery network (CDN).

Create the calling app in Python
The code below will help to set up 2 routes on your webserver: one for creating the endpoint and the other for deleting it
1. Copy the code below into a text file and save it as phone.py.
2. Replace Your AUTH_ID and Your AUTH_TOKEN in both routes with the AUTH ID and AUTH TOKEN found on your Plivo dashboard.


 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import plivo, plivoxml
from flask import Flask, request, render_template
import random

app = Flask(__name__)

# Create an Endpoint
@app.route('/', methods=['GET','POST'])
def phone():
        auth_id = "Your AUTH_ID"
        auth_token = "Your AUTH_TOKEN"

        p = plivo.RestAPI(auth_id, auth_token)
        # Generate a random username
        username = ''.join([random.choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(6)])
        # Generate a random password
        password = ''.join([random.choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(6)])

        # Print the generated username and password
        print "Usernme ; %s " % (username)
        print "Password ; %s " % (password)

        # Create an Endpoint
        params = {
            'username': username, # The username for the endpoint to be created
            'password': password, # The password for your endpoint username
            'alias' : username # Alias for the endpoint
        }

        response = p.create_endpoint(params)
        # Print the response
        print str(response)

        # Fetch the username of the created Endpoint
        uname = response[1]['username']
        pwd = params['password']
        # Fetch the Endpoint ID
        endpoint_id = response[1]['endpoint_id']

        # Print the Endpoint details
        print "Username : %s " % (uname)
        print "Password : %s " % (pwd)
        print "Endpoint ID : %s " % (endpoint_id)

        # Render the phone.html page
        return render_template('phone.html', username=uname, password=pwd, endpoint_id=endpoint_id)

# Delete an Endpoint
@app.route("/delete_endpoint/<endpoint_id>/", methods=['GET','POST'])
def delete_endpoint(endpoint_id):
        print endpoint_id
        auth_id = "Your AUTH_ID"
        auth_token = "Your AUTH_TOKEN"

        p = plivo.RestAPI(auth_id, auth_token)
        params = {
            'endpoint_id' : endpoint_id # ID of the endpoint that as to be deleted
        }

        # Delete the created Enpoint
        response = p.delete_endpoint(params)

        # Print the response
        print str(response)
        # Return the response
        return str(response)

if __name__ == "__main__":
    app.run(host='0.0.0.0', debug=True)

Render the HTML file
Assuming that your web server is located at www.example.com, the following HTML file will be rendered when we send an HTTP request to www.example.com/dynamic_endpoint.
1. Create a folder called templates in the same path as the phone.py. For example, if phone.py was saved in the folder /documents/websdkapp/ then the new folder would be /documents/websdkapp/templates.
2. Download phone.html and save it to the "templates" folder that you just created (e.g., /documents/websdkapp/templates/phone.html).
3. Make an HTTP request to www.example.com/dynamic_endpoint. This will instruct the phone.py app to render the phone.html file.
4. Edit the following snippet in phone.html to login using the created endpoint and delete the endpoint upon logging out.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function login() {
    var username = '{{username}}';
    var password = '{{password}}';
    Plivo.conn.login(username, password);
}
function logout() {
    var endpoint_id = '{{endpoint_id}}';
    Plivo.conn.logout();
    $.get( "/delete_endpoint/" + endpoint_id + "/", function( data ) {
    console.log("Endpoint deleted");
    });
}


Download the asset files
To build the web app, we first need all the static assets that will be supporting your web app (e.g., CSS, JavaScript, images, etc).
1. Create a "public" folder in the root directory of your app.
2. Download assets.zip and save it in the "public" folder that you just created 3. Serve up the asset files either directly through the web server or by using a content delivery network (CDN).

Create the calling app in Ruby
The code below will help to set up 2 routes on your webserver: one for creating the endpoint and the other for deleting it
1. Copy the code below into a text file and save it as phone.rb.
2. Replace Your AUTH_ID and Your AUTH_TOKEN in both routes with the AUTH ID and AUTH TOKEN found on your Plivo dashboard.


 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
require 'plivo'
require 'sinatra'
require 'rubygems'
include Plivo

get '/' do
    auth_id = "Your AUTH_ID"
    auth_token = "Your AUTH_TOKEN"
    
    p = RestAPI.new(auth_id, auth_token)

    username = (0...8).map{ ('a'..'z').to_a[rand(26)]  }.join
    password = (0...8).map{ ('a'..'z').to_a[rand(26)]  }.join

    # Create an Endpoint
    params = {
        'username' => username, # The username for the endpoint to be created
        'password'=> password, # The password for your endpoint username
        'alias' => username # Alias for the endpoint
    }

    response = p.create_endpoint(params)
    
    # Print the response
    print response

    # Fetch the username of the created Endpoint
    uname = response[1]['username']
    pwd = params['password']
    # Fetch the Endpoint ID
    endpoint_id = response[1]['endpoint_id']

    erb :phone, :locals => {:username => uname, :password => pwd, :end_id => endpoint_id}

end

# Delete an Endpoint
get '/delete_endpoint/:endpoint_id/' do

    endpoint_id = params[:endpoint_id]
    print endpoint_id
    auth_id = "Your AUTH_ID"
    auth_token = "Your AUTH_TOKEN"

    p = RestAPI.new(auth_id, auth_token)

    params = {
        'endpoint_id' => endpoint_id # ID of the endpoint that as to be deleted
    }

    # Delete the created Enpoint
    response = p.delete_endpoint(params)

    # Print the response
    print response
    
end

Render the HTML file
Assuming that your web server is located at www.example.com, the following HTML file will be rendered when we send an HTTP request to www.example.com/dynamic_endpoint.
1. Create a folder called views in the same path as the phone.rb. For example, if phone.rb was saved in the folder /documents/websdkapp/ then the new folder would be /documents/websdkapp/views.
2. Download phone.erb and save it to the "views" folder that you just created (e.g., /documents/websdkapp/views/phone.erb).
3. Make an HTTP request to www.example.com/dynamic_endpoint. This will instruct the phone.rb app to render the phone.erb file.
4. Edit the following snippet in phone.erb to login using the created endpoint and delete the endpoint upon logout.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function login() {
    var username = "<%= username %>";
    var password = "<%= password %>";
    Plivo.conn.login(username, password);
}
function logout() {
    var endpoint_id = "<%= end_id %>";
    Plivo.conn.logout();
    $.get( "/delete_endpoint/" + endpoint_id + "/", function( data ) {
        console.log("Endpoint deleted");
    });
}


Download the asset files
To build the web app, we first need all the static assets that will be supporting your web app (e.g., CSS, JavaScript, images, etc).
1. Create a "static" folder in the root directory of your app.
2. Download assets.zip and save it in the "static" folder that you just created
2. Serve up the asset files either directly through the web server or by using a content delivery network (CDN).

Create the calling app in PHP
The code below will help to set up 2 routes on your webserver: one for creating the endpoint and the other for deleting it. The create_endpoint.php app creates the endpoint and renders the web page, while the delete_endpoint.php app deletes the endpoint.
1. Copy the code below into a text file and save it as create_endpoint.php.
2. Replace Your AUTH_ID and Your AUTH_TOKEN with the AUTH ID and AUTH TOKEN found on your Plivo dashboard.
3. Download phone.html and copy it's contents into create_endpoint.php and save it.

 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";
    
    $length = 6;
    $username = substr(str_shuffle("abcdefghijklmnopqrstuvwxyz"), 0, $length);
    $password = substr(str_shuffle("abcdefghijklmnopqrstuvwxyz"), 0, $length);

    $p = new RestAPI($auth_id, $auth_token);
    $params = array(
            'username' => $username,
            'password' => $password,
            'alias' => $username
        );
    $response = $p->create_endpoint($params);
    $uname = $response['response']['username'];
    $end_id = $response['response']['endpoint_id'];
?>

3. Edit the following snippet in create_endpoint.php to login using the created endpoint and delete the endpoint upon logging out.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function login() {
    var username = "<?php echo $uname; ?>";
    var password = "<?php echo $password; ?>";
    Plivo.conn.login(username, password);
}
function logout() {
    var end_id = "<?php echo $end_id; ?>";
    $.get( "/delete_endpoint.php?endpoint_id=" + end_id, function( data ) { 
        console.log("delete endpoint status: " + data) 
    });
    Plivo.conn.logout();
}

4. Copy the code below into a text file and save it as delete_endpoint.php.
5. Replace Your AUTH_ID and Your AUTH_TOKEN with the AUTH ID and AUTH TOKEN found on your Plivo dashboard.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<?php
    require 'vendor/autoload.php';
    use Plivo\RestAPI;
    $auth_id = "Your AUTH_ID";
    $auth_token = "Your AUTH_TOKEN";
    $endpoint_id = $_GET['endpoint_id'];
    $p = new RestAPI($auth_id, $auth_token);
    $params = array(
        'endpoint_id' => $endpoint_id
    );
    $response = $p->delete_endpoint($params);
    return "Deleted";
?>


Download the asset files
To build the web app, we first need all the static assets that will be supporting your web app (e.g., CSS, JavaScript, images, etc).
1. Create a "static" folder in the root directory of your app.
2. Download assets.zip and save it in the "static" folder that you just created. 2. Serve up the asset files either directly through the web server or by using a content delivery network (CDN).

Create the calling app in .NET
The code below will help to set up 2 routes on your webserver: one for creating the endpoint and the other for deleting it. The create_endpoint.cshtml app creates the endpoint and renders the web page, while the delete_endpoint.cshtml app deletes the endpoint.
1. Copy the code below into a text file and save it as create_endpoint.cshtml.
2. Replace Your AUTH_ID and Your AUTH_TOKEN with the AUTH ID and AUTH TOKEN found on your Plivo dashboard.
3. Download phone.html and copy it's contents into create_endpoint.cshtml and save it.

 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
33
34
35
36
37
38
39
40
41
42
43
@using Plivo.API;
@using RestSharp;
@{
    string auth_id = "Your AUTH_ID";
    string auth_token = "Your AUTH_TOKEN";
    
    RestAPI plivo = new RestAPI(auth_id, auth_token);

    // Generate Random username and password
    var chars = "abcdefghijklmnopqrstuvwxyz";
    var stringChars = new char[6];
    var stringPass = new char[6];
    var random = new Random();
    
    for (int i=0; i<stringChars.Length; i++){
        stringChars[i] = chars[random.Next(chars.Length)];
        stringPass[i] = chars[random.Next(chars.Length)];
    }
    
    var finalUname = new String(stringChars);
    var finalPass = new String(stringPass);
    
    System.Diagnostics.Debug.WriteLine(finalUname);
    System.Diagnostics.Debug.WriteLine(finalPass);
    
    // Create an endpoint
    IRestResponse<Endpoint> resp = plivo.create_endpoint(new Dictionary<string,string>(){
        {"username",finalUname},
        {"password",finalPass},
        {"alias",finalUname}
        
    });

    // Print the response
    System.Diagnostics.Debug.WriteLine(resp.Content);

    // Get the complete username
    String username = resp.Data.username.ToString();
    System.Diagnostics.Debug.WriteLine(username);

    // Get the endpoint id
    String end_id = resp.Data.endpoint_id;    
}

3. Edit the following snippet in create_endpoint.cshtml to login using the created endpoint and delete the endpoint upon logging out.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
function login() {
    console.log("@username");
    console.log("@finalPass");
    Plivo.conn.login("@username", "@finalPass");
}
function logout() {
    var end_id = "@end_id";
    Plivo.conn.logout();
    console.log(end_id);
    $.get("/delete.cshtml?endpoint_id=" + end_id, function (data) { 
        console.log("delete endpoint status: " + data) 
    }); 
}

4. Copy the code below into a text file and save it as delete_endpoint.cshtml.
5. Replace Your AUTH_ID and Your AUTH_TOKEN with the AUTH ID and AUTH TOKEN found on your Plivo dashboard.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
@using Plivo.API;
@using RestSharp; 
@{
    // Store the endpoint point id from the URL
    var endid = Request.QueryString["endpoint_id"];
    
    string auth_id = "Your AUTH_ID";
    string auth_token = "Your AUTH_TOKEN";

    RestAPI p = new RestAPI(auth_id, auth_token);

    System.Diagnostics.Debug.WriteLine("Deleting the Endpoint");
    
    // Delete the endpoint
    IRestResponse<GenericResponse> response = p.delete_endpoint(new Dictionary<string, string>()
        {
            {"endpoint_id", endid}
        });
    
    System.Diagnostics.Debug.WriteLine("Deleted"); 
}


Download the asset files
To build the web app, we first need all the static assets that will be supporting your web app (e.g., CSS, JavaScript, images, etc).
1. 1. Create a "WebContent" folder in the main directory of your app (i.e., "src/main/WebContent").
2. Download assets.zip and save it in the "static" folder that you just created.
2. Serve up the asset files either directly through the web server or by using a content delivery network (CDN).

Create the calling app in Java
The code below will help to set up 2 routes on your webserver: one for creating the endpoint and the other for deleting it. The create_endpoint.java app creates the endpoint and renders the web page, while the delete_endpoint.java app deletes the endpoint.
1. Copy the code below into a text file and save it as create_endpoint.java.
2. Replace Your AUTH_ID and Your AUTH_TOKEN with the AUTH ID and AUTH TOKEN found on your Plivo dashboard.

 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package web_phne;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;

import com.plivo.helper.api.client.RestAPI;
import com.plivo.helper.api.response.endpoint.Endpoint;
import com.plivo.helper.exception.PlivoException;

import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Random;

@WebServlet("/")
public class createEndpoint extends HttpServlet {
    public void service(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {

        String auth_id = "Your AUTH_ID";
        String auth_token = "Your AUUTH_TOKEN";

        char username, password;
        String uname = "";
        String end_id = "";
        
        // Generate a random usernam and password
        Random r = new Random();
        StringBuffer randStr = new StringBuffer();
        StringBuffer randString = new StringBuffer();
        for(int i=0; i<6; i++){
            username = (char)(r.nextInt(26) + 'a');
            password = (char)(r.nextInt(26) + 'a');
            randStr.append(username);
            randString.append(password);
        }
        String finalUsername = randStr.toString();
        String finalPassword = randString.toString();
        
        RestAPI api = new RestAPI(auth_id, auth_token, "v1");
        
        // Create an Endpoint
        LinkedHashMap<String, String> parameters = new LinkedHashMap<String, String>();
        parameters.put("username", finalUsername);
        parameters.put("password", finalPassword);
        parameters.put("alias", finalUsername);
        
        try {
            Endpoint resp = api.createEndpoint(parameters);
            // Get the created Endpoint ID and username
            end_id = resp.endpointId.toString();
            uname = resp.username.toString();
        }catch (PlivoException e){
            System.out.println(e.getLocalizedMessage());
        }
        
        // Forward the username, password and endpoint id information to a JSP view
        response.setContentType("text/html");
        request.setAttribute("username", uname);
        request.setAttribute("password", finalPassword);
        request.setAttribute("endpoint_id", end_id);
        RequestDispatcher view = request.getRequestDispatcher("phone.jsp");
        view.forward(request, response);
    }
}

3. Copy the code below into a text file and save it as delete_endpoint.java.
4. Replace Your AUTH_ID and Your AUTH_TOKEN with the AUTH ID and AUTH TOKEN found on your Plivo dashboard.

 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
33
34
35
36
37
38
39
package web_phne;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;

import com.plivo.helper.api.client.RestAPI;
import com.plivo.helper.api.response.response.GenericResponse;
import com.plivo.helper.exception.PlivoException;

import java.io.IOException;
import java.util.LinkedHashMap;

@WebServlet("/delete")
public class deleteEndpoint extends HttpServlet {
    public void service(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {

        String auth_id = "Your AUTH_ID";
        String auth_token = "Your AUTH_TOKEN";
        
        // Fetch the endpoint id from the query url
        String end_id = request.getParameter("endpoint_id");
        
        RestAPI api = new RestAPI(auth_id, auth_token, "v1");
        
        // Delete the endpoint
        LinkedHashMap<String, String> parameters = new LinkedHashMap<String, String>();
        parameters.put("endpoint_id", end_id); 
        
        try {
            GenericResponse resp = api.deleteEndpoint(parameters);
            // Print the response
            System.out.println(resp.message);
        }catch (PlivoException e){
            System.out.println(e.getLocalizedMessage());
        }
    }
}


Render the HTML file
Assuming that your web server is located at www.example.com, the following HTML file will be rendered when we send an HTTP request to www.example.com/dynamic_endpoint.
1. Create a folder called WebContent in the same path as the create_endpoint.java. For example, if create_endpoint.java was saved in the folder /documents/websdkapp/ then the new folder would be /documents/websdkapp/WebContent.
2. Download phone.jsp and save it to the "WebContent" folder that you just created (e.g., /documents/websdkapp/WebContent/phone.jsp).
3. Make an HTTP request to www.example.com/dynamic_endpoint. This will instruct the create_endpoint.java app to render the phone.jsp file.
4. Edit the following snippet in phone.jsp to login using the created endpoint and delete the endpoint upon logout.



function login() {
    var uname = '<%= request.getAttribute("username") %>';
    var password = '<%= request.getAttribute("password") %>';
    Plivo.conn.login(uname, password);
}
function logout() {
    var end_id = '<%= request.getAttribute("endpoint_id") %>';
    $.get("/web_phne/delete?endpoint_id=" + end_id, function (data) { 
        console.log("delete endpoint status: " + data) 
    });
    Plivo.conn.logout();
}


Step 5: Test it out

  1. To initiate a call, load your app URL www.example.com/dynamic_endpoint into a browser (use www.example.com/make_outgoing.php if you built your app using PHP).
  2. To enable your computer microphone for the app by clicking "Allow" when prompted by your browser.
  3. Allow media in browser

    Note: Plivo's web SDK supports most modern browsers. Even if the browser does not support HTML5, it will automatically fallback to Flash with full functionality.
    Allow media in browser

  4. Click "login" to login automatically and dynamically create a SIP endpoint in the back end.
  5. Enter the destination phone number in the text field and click 'Call'. Be sure that the phone number include country code, area code, and phone number without spaces or dashes (e.g., 14153336666).
  6. screenshot make a call to a phone
  7. The call status will indicate the stage of the call (e.g., "Ready", "Connecting", "Ringing", and "Call Answered"). Once the call is answered, you may click "End" to hangup the call.
  8. screenshot call is answered
  9. Once the call is completed and the caller clicks "logout", the SIP endpoint is deleted.

    1. Web SDK Quick Start
    2. Make a Call With a Browser to a Phone Number
    3. Make a Call With a Browser to a SIP Endpoint
    4. Hangup the Call
    5. Manually Input Destination Phone Numbers
    6. Pre-program Destination Phone Numbers (Click-to-call)
    7. Modify the Login Interface
    8. Receive Incoming Calls