LiveKit Integration

Connect Plivo SIP trunking to LiveKit to enable your voice AI applications to make and receive phone calls through Plivo’s global voice network. You can configure Plivo using the API or the Console; each step in this guide includes both options.

Prerequisites

Requirement	Description
Plivo Account	Sign up with SIP trunking enabled
Phone Number	Purchase a voice-enabled number India: Requires KYC verification. See Rent India Numbers.
LiveKit Cloud Project	Create a project

If you’re using the API, you also need your Plivo Auth ID and Auth Token, available on the Plivo Console home page. The Plivo API uses HTTP Basic authentication. Export your credentials as environment variables to use with the code samples in this guide:

export PLIVO_AUTH_ID="<your_auth_id>"
export PLIVO_AUTH_TOKEN="<your_auth_token>"

Optimize for latency: Select the LiveKit region closest to your call traffic. This minimizes audio delay and improves conversation flow.

India regional requirement: If your calls are made from a Plivo India phone number, or you’re dialing numbers in India, you must enable region pinning for your LiveKit project. This is a regulatory requirement; calls will fail to connect otherwise. See Calling in India.

Part 1: Receive incoming calls

Route calls from your Plivo phone number to LiveKit.

Create an inbound trunk in Plivo

Create an inbound trunk in Plivo, setting your LiveKit SIP endpoint as the primary URI.

API
Console

First, create an origination URI that points to your LiveKit SIP endpoint. Include ;transport=tcp in the URI:

curl "https://api.plivo.com/v1/Account/$PLIVO_AUTH_ID/Zentrunk/URI/" \
-u "$PLIVO_AUTH_ID:$PLIVO_AUTH_TOKEN" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-d '{
  "name": "LiveKit SIP endpoint",
  "uri": "<livekit_sip_host>;transport=tcp"
}'

const authId = process.env.PLIVO_AUTH_ID;
const authToken = process.env.PLIVO_AUTH_TOKEN;
const authHeader = 'Basic ' + Buffer.from(`${authId}:${authToken}`).toString('base64');

const response = await fetch(`https://api.plivo.com/v1/Account/${authId}/Zentrunk/URI/`, {
  method: 'POST',
  headers: {
    'Authorization': authHeader,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'LiveKit SIP endpoint',
    uri: '<livekit_sip_host>;transport=tcp',
  }),
});
console.log(await response.json());

import os
import requests

auth_id = os.environ["PLIVO_AUTH_ID"]
auth_token = os.environ["PLIVO_AUTH_TOKEN"]

response = requests.post(
    f"https://api.plivo.com/v1/Account/{auth_id}/Zentrunk/URI/",
    auth=(auth_id, auth_token),
    json={
        "name": "LiveKit SIP endpoint",
        "uri": "<livekit_sip_host>;transport=tcp",
    },
)
print(response.json())

Copy the uri_uuid from the response for the next step:

{
  "api_id": "<api_id>",
  "message": "Origination URI created successfully",
  "uri_uuid": "<uri_uuid>"
}

Next, create an inbound trunk using the origination URI as the primary URI:

curl "https://api.plivo.com/v1/Account/$PLIVO_AUTH_ID/Zentrunk/Trunk/" \
-u "$PLIVO_AUTH_ID:$PLIVO_AUTH_TOKEN" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-d '{
  "name": "My LiveKit inbound trunk",
  "trunk_direction": "inbound",
  "primary_uri_uuid": "<uri_uuid>"
}'

const authId = process.env.PLIVO_AUTH_ID;
const authToken = process.env.PLIVO_AUTH_TOKEN;
const authHeader = 'Basic ' + Buffer.from(`${authId}:${authToken}`).toString('base64');

const response = await fetch(`https://api.plivo.com/v1/Account/${authId}/Zentrunk/Trunk/`, {
  method: 'POST',
  headers: {
    'Authorization': authHeader,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'My LiveKit inbound trunk',
    trunk_direction: 'inbound',
    primary_uri_uuid: '<uri_uuid>',
  }),
});
console.log(await response.json());

import os
import requests

auth_id = os.environ["PLIVO_AUTH_ID"]
auth_token = os.environ["PLIVO_AUTH_TOKEN"]

response = requests.post(
    f"https://api.plivo.com/v1/Account/{auth_id}/Zentrunk/Trunk/",
    auth=(auth_id, auth_token),
    json={
        "name": "My LiveKit inbound trunk",
        "trunk_direction": "inbound",
        "primary_uri_uuid": "<uri_uuid>",
    },
)
print(response.json())

Copy the trunk_id from the response. You use it to connect your phone number in the next step:

{
  "api_id": "<api_id>",
  "message": "Trunk created successfully.",
  "trunk_id": "<trunk_id>"
}

Sign in to the Plivo Console.
Navigate to SIP Trunking → Inbound Trunks.
Select Create Trunk and provide a descriptive name for your trunk.
For Primary URI, select Add New URI and enter your LiveKit SIP endpoint. Include ;transport=tcp in the URI. For example, vjnxecm0tjk.sip.livekit.cloud;transport=tcp.
For Link Numbers, select your phone number from the dropdown menu. Or connect your phone number in the next step.
Select Create Trunk.

Secure trunking: If you’re setting up secure trunking, use ;transport=tls instead of ;transport=tcp.

Region-based endpoints: To restrict calls to a specific region, replace your global LiveKit SIP endpoint with a region-based endpoint.

Connect your phone number

Connect your Plivo phone number to the inbound trunk. You can skip this step if you connected your phone number when you created the inbound trunk.

API
Console

Assign the inbound trunk to your phone number using the update a number endpoint. Set the app_id field to the trunk ID of your inbound trunk. Use your phone number in E.164 format without the leading +. For example, 15105550100:

curl "https://api.plivo.com/v1/Account/$PLIVO_AUTH_ID/Number/15105550100/" \
-u "$PLIVO_AUTH_ID:$PLIVO_AUTH_TOKEN" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-d '{
  "app_id": "<trunk_id>"
}'

const authId = process.env.PLIVO_AUTH_ID;
const authToken = process.env.PLIVO_AUTH_TOKEN;
const authHeader = 'Basic ' + Buffer.from(`${authId}:${authToken}`).toString('base64');
const phoneNumber = '15105550100';

const response = await fetch(`https://api.plivo.com/v1/Account/${authId}/Number/${phoneNumber}/`, {
  method: 'POST',
  headers: {
    'Authorization': authHeader,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    app_id: '<trunk_id>',
  }),
});
console.log(await response.json());

import os
import requests

auth_id = os.environ["PLIVO_AUTH_ID"]
auth_token = os.environ["PLIVO_AUTH_TOKEN"]
phone_number = "15105550100"

response = requests.post(
    f"https://api.plivo.com/v1/Account/{auth_id}/Number/{phone_number}/",
    auth=(auth_id, auth_token),
    json={
        "app_id": "<trunk_id>",
    },
)
print(response.json())

A successful response returns HTTP 202:

{
  "api_id": "<api_id>",
  "message": "changed"
}

To list your purchased numbers, run the following command:

curl "https://api.plivo.com/v1/Account/$PLIVO_AUTH_ID/Number/" \
-u "$PLIVO_AUTH_ID:$PLIVO_AUTH_TOKEN" \
-H 'Accept: application/json'

const authId = process.env.PLIVO_AUTH_ID;
const authToken = process.env.PLIVO_AUTH_TOKEN;
const authHeader = 'Basic ' + Buffer.from(`${authId}:${authToken}`).toString('base64');

const response = await fetch(`https://api.plivo.com/v1/Account/${authId}/Number/`, {
  headers: { 'Authorization': authHeader },
});
console.log(await response.json());

import os
import requests

auth_id = os.environ["PLIVO_AUTH_ID"]
auth_token = os.environ["PLIVO_AUTH_TOKEN"]

response = requests.get(
    f"https://api.plivo.com/v1/Account/{auth_id}/Number/",
    auth=(auth_id, auth_token),
)
print(response.json())

Configure LiveKit to accept calls

Set up an inbound trunk and dispatch rule in LiveKit to accept calls to your Plivo phone number.

Test incoming calls

Start your LiveKit agent and call your Plivo phone number. Your agent should answer the call. If you don’t have an agent, see the Voice AI quickstart to create one.

Part 2: Make outgoing calls

Enable LiveKit to make outbound calls through Plivo.

Create an outbound trunk in Plivo

Set up an outbound trunk with username and password authentication in Plivo.

API
Console

First, create a credential with a username and strong password for outbound call authentication:

Username: 5 to 20 characters, alphanumeric only.
Password: 5 to 20 characters, using only alphanumeric characters and the special characters ~!@#$%^&*()_+, with at least one special character.
Use the same username and password when you configure your LiveKit outbound trunk.

curl "https://api.plivo.com/v1/Account/$PLIVO_AUTH_ID/Zentrunk/Credential/" \
-u "$PLIVO_AUTH_ID:$PLIVO_AUTH_TOKEN" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-d '{
  "name": "LiveKit outbound credential",
  "username": "<username>",
  "password": "<password>"
}'

const authId = process.env.PLIVO_AUTH_ID;
const authToken = process.env.PLIVO_AUTH_TOKEN;
const authHeader = 'Basic ' + Buffer.from(`${authId}:${authToken}`).toString('base64');

const response = await fetch(`https://api.plivo.com/v1/Account/${authId}/Zentrunk/Credential/`, {
  method: 'POST',
  headers: {
    'Authorization': authHeader,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'LiveKit outbound credential',
    username: '<username>',
    password: '<password>',
  }),
});
console.log(await response.json());

import os
import requests

auth_id = os.environ["PLIVO_AUTH_ID"]
auth_token = os.environ["PLIVO_AUTH_TOKEN"]

response = requests.post(
    f"https://api.plivo.com/v1/Account/{auth_id}/Zentrunk/Credential/",
    auth=(auth_id, auth_token),
    json={
        "name": "LiveKit outbound credential",
        "username": "<username>",
        "password": "<password>",
    },
)
print(response.json())

Copy the credential_uuid from the response for the next step:

{
  "api_id": "<api_id>",
  "message": "Credential created successfully",
  "credential_uuid": "<credential_uuid>"
}

Next, create an outbound trunk using the credential:

curl "https://api.plivo.com/v1/Account/$PLIVO_AUTH_ID/Zentrunk/Trunk/" \
-u "$PLIVO_AUTH_ID:$PLIVO_AUTH_TOKEN" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-d '{
  "name": "My LiveKit outbound trunk",
  "trunk_direction": "outbound",
  "credential_uuid": "<credential_uuid>",
  "secure": true
}'

const authId = process.env.PLIVO_AUTH_ID;
const authToken = process.env.PLIVO_AUTH_TOKEN;
const authHeader = 'Basic ' + Buffer.from(`${authId}:${authToken}`).toString('base64');

const response = await fetch(`https://api.plivo.com/v1/Account/${authId}/Zentrunk/Trunk/`, {
  method: 'POST',
  headers: {
    'Authorization': authHeader,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'My LiveKit outbound trunk',
    trunk_direction: 'outbound',
    credential_uuid: '<credential_uuid>',
    secure: true,
  }),
});
console.log(await response.json());

import os
import requests

auth_id = os.environ["PLIVO_AUTH_ID"]
auth_token = os.environ["PLIVO_AUTH_TOKEN"]

response = requests.post(
    f"https://api.plivo.com/v1/Account/{auth_id}/Zentrunk/Trunk/",
    auth=(auth_id, auth_token),
    json={
        "name": "My LiveKit outbound trunk",
        "trunk_direction": "outbound",
        "credential_uuid": "<credential_uuid>",
        "secure": True,
    },
)
print(response.json())

Copy the trunk_id from the response:

{
  "api_id": "<api_id>",
  "message": "Trunk created successfully.",
  "trunk_id": "<trunk_id>"
}

Finally, retrieve the trunk to get your Termination SIP Domain. It’s returned in the trunk_domain field. For example, 21784177241578.zt.plivo.com:

curl "https://api.plivo.com/v1/Account/$PLIVO_AUTH_ID/Zentrunk/Trunk/<trunk_id>/" \
-u "$PLIVO_AUTH_ID:$PLIVO_AUTH_TOKEN" \
-H 'Accept: application/json'

const authId = process.env.PLIVO_AUTH_ID;
const authToken = process.env.PLIVO_AUTH_TOKEN;
const authHeader = 'Basic ' + Buffer.from(`${authId}:${authToken}`).toString('base64');
const trunkId = '<trunk_id>';

const response = await fetch(`https://api.plivo.com/v1/Account/${authId}/Zentrunk/Trunk/${trunkId}/`, {
  headers: { 'Authorization': authHeader },
});
console.log(await response.json());

import os
import requests

auth_id = os.environ["PLIVO_AUTH_ID"]
auth_token = os.environ["PLIVO_AUTH_TOKEN"]
trunk_id = "<trunk_id>"

response = requests.get(
    f"https://api.plivo.com/v1/Account/{auth_id}/Zentrunk/Trunk/{trunk_id}/",
    auth=(auth_id, auth_token),
)
print(response.json())

{
  "api_id": "<api_id>",
  "object": {
    "trunk_id": "<trunk_id>",
    "name": "My LiveKit outbound trunk",
    "trunk_status": "enabled",
    "secure": true,
    "trunk_domain": "<trunk_id>.zt.plivo.com",
    "trunk_direction": "outbound",
    "ipacl_uuid": null,
    "credential_uuid": "<credential_uuid>",
    "primary_uri_uuid": null,
    "fallback_uri_uuid": null
  }
}

Copy the Termination SIP Domain (trunk_domain) for the next step.

Sign in to the Plivo Console.
Navigate to SIP Trunking → Outbound Trunks.
Select Create Trunk and provide a descriptive name for your trunk.
In the Trunk Authentication section → Credential, select Create new credential.
Add a credential name, and a username and strong password for outbound call authentication, then select Create credential.
- Username: 5 to 20 characters, alphanumeric only.
- Password: 5 to 20 characters, using only alphanumeric characters and the special characters ~!@#$%^&*()_+, with at least one special character.
- Use the same username and password when you configure your LiveKit outbound trunk.
For Authentication, select the credential you created in the previous step.
Enable Secure Trunking.
Select Create Trunk to complete your outbound trunk configuration.

Copy the Termination SIP Domain for the next step.

Secure trunking: If you enable secure trunking in Plivo ("secure": true), you must also enable secure trunking in LiveKit. To learn more, see Secure trunking.

Configure LiveKit to make outbound calls

Create an outbound trunk in LiveKit using the Termination SIP Domain, username, and password from the previous step.

Place an outbound call

Test your configuration by placing an outbound call with LiveKit using the CreateSIPParticipant API. To learn more, see Creating a SIP participant.

Troubleshooting

If a call fails to connect, check the following common issues:

Issue	Solution
Call doesn’t connect	Verify your SIP URI includes `;transport=tcp`. Verify your Plivo phone number is associated with the correct trunk.
Authentication errors	Verify credentials match exactly in both Plivo and LiveKit.
India calls failing	Ensure region pinning is enabled for your LiveKit project.

Debug logs:

Inbound issues: First check the Plivo logs, then check the call logs in your LiveKit Cloud dashboard.
Outbound issues: First check the call logs in your LiveKit Cloud dashboard, then check the Plivo logs.

For error codes, see Plivo hangup codes.

SIP Trunking API overview

Plivo SIP Trunking API reference.

SIP Trunking overview

Plivo SIP trunking documentation.

LiveKit SIP documentation

Complete LiveKit SIP configuration.

LiveKit Plivo guide

LiveKit’s official Plivo integration guide.

Getting Started

Integration Guides

Deploy

Reference

LiveKit Integration

Prerequisites

Part 1: Receive incoming calls

Create an inbound trunk in Plivo

Connect your phone number

Configure LiveKit to accept calls

Test incoming calls

Part 2: Make outgoing calls

Create an outbound trunk in Plivo

Configure LiveKit to make outbound calls

Place an outbound call

Troubleshooting

SIP Trunking API overview

SIP Trunking overview

LiveKit SIP documentation

LiveKit Plivo guide

​Prerequisites

​Part 1: Receive incoming calls

Create an inbound trunk in Plivo

Connect your phone number

Configure LiveKit to accept calls

Test incoming calls

​Part 2: Make outgoing calls

Create an outbound trunk in Plivo

Configure LiveKit to make outbound calls

Place an outbound call

​Troubleshooting

​Related

SIP Trunking API overview

SIP Trunking overview

LiveKit SIP documentation

LiveKit Plivo guide

Prerequisites

Part 1: Receive incoming calls

Part 2: Make outgoing calls

Troubleshooting

Related