I want to implement my own custom sip to my self h...
# ask-ain
nutritious-businessperson-79241
03/17/2026, 7:21 AMI want to implement my own custom sip to my self hosted livekit instance and project can you give me step by step roadmap for how to do that? You have to be specific and clear.
✅ 1
t
tall-airline-16756
03/17/2026, 7:21 AMThanks for reaching out, Berfin. I'm an AI assistant and I'm here to help. Give me a moment while I research this topic.
tall-airline-16756
03/17/2026, 7:22 AMThanks — I’m glad you want a clear, step-by-step roadmap. I’ll walk you through a concrete plan to implement a custom SIP integration for your self‑hosted LiveKit instance and project. I’ll highlight exactly what to deploy, configure, and test. If you want code samples in a specific language (Go, Python, or JS) or details about your SIP provider configuration, tell me which and I’ll include those next.
Acknowledgement of your request
• You asked for a specific, clear step-by-step roadmap to add custom SIP to a self‑hosted LiveKit instance and project. I’ll cover deployment, trunk setup (inbound/outbound), dispatch rules, creating SIP participants, optional features (noise cancellation, recording), security, and testing.
Roadmap — step by step
1) Prepare your environment
• Ensure your LiveKit server is running and reachable (public hostname or IP) and you have admin API credentials for the instance.
• Plan networking: public IP/port for SIP traffic, TLS certs for SIP over TLS, and any NAT/firewall rules for RTP/UDP ranges.
2) Deploy the LiveKit SIP service
• Deploy the separate component called livekit-sip alongside your main LiveKit server (self‑hosted requires this). It must be able to call the LiveKit internal APIs to create rooms and participants.
• Expose the SIP service to the public internet (or to your SIP provider) on the port(s) you choose (UDP/TCP/TLS). Configure TLS certs if you will use SIP over TLS.
3) Choose and configure a SIP trunk provider
• Select a provider (examples: Twilio, Telnyx, Plivo, Telco of choice).
• Buy or port the phone numbers you’ll use.
• Obtain auth method from the provider: credential (username/password) or IP-based allowlist. You’ll use these to register/accept calls from the provider into your SIP endpoint.
• Point the provider’s SIP destination to your livekit-sip public address:port (and TLS if using TLS).
4) Configure inbound trunks in LiveKit
• Create an inbound trunk record in LiveKit that represents the SIP provider connection and the phone numbers that route to LiveKit.
• While creating the trunk, set:
◦ allowed IP addresses (to restrict which SIP providers can send calls)
◦ phone numbers (the numbers the trunk will accept)
◦ optional settings such as Krisp noise cancellation if you want it enabled at trunk level
• This registration tells LiveKit which numbers map to this trunk.
5) Create dispatch rules to route inbound calls to rooms
• Decide routing strategy:
◦ Single room for all calls
◦ New room per call (recommended for typical call flows) using a prefix like
call-{uuid}room_prefixCreateSIPParticipantCreateSIPParticipantn
nutritious-businessperson-79241
03/17/2026, 9:03 AMwhere will I add all of those, which project part and files
t
tall-airline-16756
03/17/2026, 9:04 AMThanks — I’ll map exactly where to put each SIP-related piece in your self‑hosted LiveKit project. I’ll assume a typical split between a backend/control plane service (manages trunks & dispatch rules) and your agent/worker (handles calls). If your project is structured differently, tell me the language and a short tree and I’ll adapt.
Quick question before I give file-level examples
• Which language is your backend and agent written in? (Python, Node/JS, or Go)
Answer that and I’ll produce exact filenames and sample snippets tailored to your repo.
Where to put each SIP responsibility (high level)
• Backend / control-plane (telephony management):
◦ Purpose: create trunks, create dispatch rules, manage trunk credentials, configure auto-egress/recording, and expose any admin endpoints or scripts to update SIP config.
◦ Where: a dedicated service or CLI module in your backend project (not inside agent code).
◦ Typical files: sip_setup.py / sip_manager.py / services/sip/*.js / cmd/sip_manager.go
◦ Runs: as a one-time setup script, cron/CI job, or an admin HTTP/API endpoint your ops team calls.
• Agent / worker (conversation logic):
◦ Purpose: join rooms, run the voice agent, respond to calls, optionally initiate outbound calls using CreateSIPParticipant.
◦ Where: agent codebase (separate process from the LiveKit server and from the control-plane).
◦ Typical files: agent.py / entrypoint.py / agents/voice_agent.js / handlers/sip_agent.go
◦ Note: Agents should not manage trunk lifecycle (creation/deletion); they only react to rooms and may call the API to create a SIP participant for outbound calls.
• Environment / config:
◦ Purpose: store LiveKit API credentials, SIP trunk IDs, provider credentials, RTP port ranges, TLS cert locations.
◦ Where: .env, config/_.yaml or config/_.toml, or secrets manager.
◦ Typical keys: LIVEKIT_URL, LIVEKIT_API_KEY, LIVEKIT_API_SECRET, SIP_INBOUND_TRUNK_ID, SIP_OUTBOUND_TRUNK_ID
• livekit-sip service (infrastructure repo or k8s manifests):
◦ Purpose: the actual SIP gateway process that speaks SIP to the provider and communicates with LiveKit.
◦ Where: infra/ or deployments/ (k8s manifests, docker-compose files)
◦ Typical files: deployments/livekit-sip-deployment.yaml, helm/values.yaml, docker-compose.yml
Concrete placement examples (choose your stack)
• If your backend is Python and agent is Python:
◦ Backend:
▪︎ repo/backend/sip_setup.py — scripts that call LiveKit API to create trunks and dispatch rules
▪︎ repo/backend/services/sip_manager.py — wrapper functions to list/create/update trunks and rules
▪︎ repo/backend/routes/admin_sip.py — admin HTTP endpoints to trigger trunk creation or update
◦ Agent:
▪︎ repo/agent/agent_entrypoint.py — agent startup and Room join logic
▪︎ repo/agent/functions/outbound_call.py — function tool that calls
CreateSIPParticipantCreateSIPParticipantn
nutritious-businessperson-79241
03/17/2026, 9:06 AMI use python, I have a ready project running on a vm with both livekit instance and project files. Please provide your explanations for this direction
t
tall-airline-16756
03/17/2026, 9:07 AMGreat — since you’re running a self‑hosted LiveKit instance and your project is Python on a VM, here’s a clear, practical map of exactly which files to add or modify, where to put them, and what each one should do. I’ll keep it executable and focused so you can copy/paste and run.
High‑level structure I recommend (example repo layout)
• infra/ # deployment manifests for livekit-sip
◦ livekit-sip-deployment.yaml
◦ firewall.md
• backend/ # control-plane service that manages SIP trunks & rules
◦ sip_setup.py
◦ sip_manager.py
◦ routes.py (optional admin HTTP endpoints)
◦ requirements.txt
• agent/ # your agent/worker handling rooms and calls
◦ agent_entrypoint.py
◦ outbound_call.py
◦ requirements.txt
• .env # environment variables (not checked into git)
• README.md
Which component gets what (short summary)
• infra/: Deployment files for the livekit-sip gateway process and any firewall/NAT notes.
• backend/: Control‑plane code that creates and manages SIP trunks and dispatch rules using the LiveKit Server SDK (Python). This is where you put
sip_setup.pysip_manager.pyCreateSIPParticipant Copy code
# backend/sip_setup.py
import os, asyncio
from livekit import api
from livekit.api import (
CreateSIPInboundTrunkRequest, SIPInboundTrunkInfo,
CreateSIPDispatchRuleRequest, SIPDispatchRule, SIPDispatchRuleIndividual
)
async def setup():
lk = api.LiveKitAPI(
url=os.environ["LIVEKIT_URL"],
api_key=os.environ["LIVEKIT_API_KEY"],
api_secret=os.environ["LIVEKIT_API_SECRET"]
)
# Create inbound trunk
trunk_req = CreateSIPInboundTrunkRequest(
trunk=SIPInboundTrunkInfo(
name="vm-inbound-trunk",
numbers=[os.environ.get("PHONE_NUMBER")], # e.g. "+1234567890"
krisp_enabled=True
)
)
trunk = await lk.sip.create_sip_inbound_trunk(trunk_req)
print("Created trunk id:", trunk.sip_trunk_id)
# Dispatch rule: new room per call prefixed with "call-"
dispatch_req = CreateSIPDispatchRuleRequest(
trunk_ids=[trunk.sip_trunk_id],
rule=SIPDispatchRule(
dispatch_rule_individual=SIPDispatchRuleIndividual(room_prefix="call")
)
)
rule = await lk.sip.create_sip_dispatch_rule(dispatch_req)
print("Created dispatch rule id:", rule.sip_dispatch_rule_id)
# Persist ids to environment/secrets store or print them for manual copy
print("Set SIP_INBOUND_TRUNK_ID and SIP_DISPATCH_RULE_ID in your .env")
if __name__ == "__main__":
asyncio.run(setup()) Copy code
# agent/agent_entrypoint.py
import os
from livekit_agents import Server, JobContext # conceptual
# Your agent framework imports...
async def entrypoint(ctx: JobContext):
# ctx.room is the LiveKit room for a SIP call created by dispatch rule
# Implement your voice agent/session here
await handle_call(ctx.room)
if __name__ == "__main__":
# Start agent worker that listens for jobs dispatched by LiveKit
Server.run(entrypoint) Copy code
# agent/outbound_call.py
import os
from livekit import api
async def place_outbound_call(room_name, to_number):
lk = api.LiveKitAPI(url=os.environ["LIVEKIT_URL"],
api_key=os.environ["LIVEKIT_API_KEY"],
api_secret=os.environ["LIVEKIT_API_SECRET"])
await lk.sip.create_sip_participant(
api.CreateSIPParticipantRequest(
sip_trunk_id=os.environ["SIP_OUTBOUND_TRUNK_ID"],
sip_call_to=to_number,
room_name=room_name,
participant_name="agent-outbound",
krisp_enabled=True
)
).envallowed_addressesn
nutritious-businessperson-79241
03/17/2026, 9:15 AMI just want to implement inbound calls, rearrange your output behalf of this
t
tall-airline-16756
03/17/2026, 9:16 AMThanks — I’ll focus only on inbound calls and give a concise, practical plan you can drop into your VM project. I’ll show exactly which files to add, what each does, and the precise Python code to create an inbound trunk and dispatch rule so incoming PSTN calls reach LiveKit rooms.
Assumptions
• You have LiveKit and livekit-sip running on your VM and reachable from the public internet.
• You have a SIP provider/phone number ready to point to your livekit-sip public address.
• Your project is Python and already runs on the same VM.
Recommended repo layout (minimal)
• infra/
◦ livekit-sip-deployment.yaml (or docker-compose/systemd notes)
◦ firewall.md
• backend/
◦ sip_setup.py ← create inbound trunk & dispatch rule (run once)
◦ sip_manager.py ← reusable helper functions (optional)
◦ requirements.txt
• agent/
◦ agent_entrypoint.py ← your existing agent (unchanged for inbound)
• .env ← secrets & trunk IDs (not checked in)
Exact files and contents
1) backend/sip_setup.py
• Purpose: Create an inbound SIP trunk and attach a dispatch rule that creates a room per call (prefix "call-").
• Run once (or via a controlled CI job) to register phone numbers and routing in LiveKit.
Place this file at backend/sip_setup.py and fill environment variables in .env.
Code (copy into backend/sip_setup.py):
Copy code
import os
import asyncio
from livekit import api
from livekit.api import (
CreateSIPInboundTrunkRequest, SIPInboundTrunkInfo,
CreateSIPDispatchRuleRequest, SIPDispatchRule, SIPDispatchRuleIndividual,
ListSIPInboundTrunkRequest, ListSIPDispatchRuleRequest,
)
async def setup_inbound_trunk():
lk = api.LiveKitAPI(
url=os.environ["LIVEKIT_URL"],
api_key=os.environ["LIVEKIT_API_KEY"],
api_secret=os.environ["LIVEKIT_API_SECRET"],
)
phone_number = os.environ["PHONE_NUMBER"] # e.g. "+1234567890"
# Optional: avoid duplicate trunks by checking existing numbers
existing = await lk.sip.list_sip_inbound_trunk(ListSIPInboundTrunkRequest())
for t in existing.items:
if phone_number in (t.numbers or []):
print("Trunk already exists for number:", phone_number)
trunk = t
break
else:
# Create inbound trunk
trunk_req = CreateSIPInboundTrunkRequest(
trunk=SIPInboundTrunkInfo(
name="vm-inbound-trunk",
numbers=[phone_number],
krisp_enabled=True, # optional
# allowed_addresses=[os.environ.get("SIP_PROVIDER_IP")] # optional
)
)
trunk = await lk.sip.create_sip_inbound_trunk(trunk_req)
print("Created trunk id:", trunk.sip_trunk_id)
# Create dispatch rule: each call -> new room with prefix "call-"
# Check for existing rule first
existing_rules = await lk.sip.list_sip_dispatch_rule(ListSIPDispatchRuleRequest())
rule_exists = False
for r in existing_rules.items:
# crude check: same trunk attached and same rule type; refine as needed
if trunk.sip_trunk_id in (r.trunk_ids or []):
rule_exists = True
rule = r
print("Found existing dispatch rule:", r.sip_dispatch_rule_id)
break
if not rule_exists:
dispatch_req = CreateSIPDispatchRuleRequest(
trunk_ids=[trunk.sip_trunk_id],
rule=SIPDispatchRule(
dispatch_rule_individual=SIPDispatchRuleIndividual(room_prefix="call")
),
)
rule = await lk.sip.create_sip_dispatch_rule(dispatch_req)
print("Created dispatch rule id:", rule.sip_dispatch_rule_id)
# Output values to save in your .env or secrets store
print("EXPORT THESE VALUES:")
print("SIP_INBOUND_TRUNK_ID=", trunk.sip_trunk_id)
print("SIP_DISPATCH_RULE_ID=", rule.sip_dispatch_rule_id)
if __name__ == "__main__":
asyncio.run(setup_inbound_trunk()) Copy code
import os
from livekit import api
def client():
return api.LiveKitAPI(
url=os.environ["LIVEKIT_URL"],
api_key=os.environ["LIVEKIT_API_KEY"],
api_secret=os.environ["LIVEKIT_API_SECRET"],
)
# Add functions: list_trunks(), delete_trunk(id), list_rules(), delete_rule(id)n
nutritious-businessperson-79241
03/17/2026, 9:19 AMthis assumption is not true:
You have LiveKit and livekit-sip running on your VM and reachable from the public internet.
I just have running LiveKit not livekit-sip. rewrite your clear suggestions
t
tall-airline-16756
03/17/2026, 9:20 AMThanks — that helps. Since you currently have only LiveKit running (no livekit-sip), I’ll give a concise, practical plan you can follow on your VM: how to deploy livekit-sip, secure networking, and then exactly where and what Python code to add to enable inbound calls. This will be focused on inbound-only calls.
Summary of steps you’ll take
1. Deploy livekit-sip on your VM (Docker or binary).
2. Open and map required ports (SIP signaling + RTP range) and add TLS if desired.
3. Configure your SIP provider to point to your livekit-sip endpoint.
4. Add Python code to your project to create an inbound trunk and a dispatch rule so incoming PSTN calls create rooms in LiveKit.
5. Test and troubleshoot.
A. Deploy livekit-sip on your VM Choose one method. Docker is easiest and keeps things isolated.
Option 1 — Docker (recommended)
• Create a docker-compose.yml (example file path: infra/docker-compose.yml) with:
◦ livekit-sip service image (use the official livekit-sip image)
◦ Environment variables pointing to your LiveKit URL and API credentials
◦ Ports:
▪︎ SIP (UDP/TCP 5060) and SIP-TLS (TCP 5061) if using TLS
▪︎ RTP range (e.g., UDP 10000–20000)
◦ Mount TLS certs if using SIP over TLS
Example (conceptual — you’ll adapt image tag and envs):
Copy code
version: '3.7'
services:
livekit-sip:
image: livekit/livekit-sip:latest
restart: unless-stopped
environment:
LIVEKIT_URL: "https://localhost:7880" # your LiveKit public/internal URL
LIVEKIT_API_KEY: "your_api_key"
LIVEKIT_API_SECRET: "your_api_secret"
# Additional configs as required by livekit-sip
ports:
- "5060:5060/udp"
- "5060:5060/tcp"
- "5061:5061/tcp" # if using TLS
- "10000-20000:10000-20000/udp"
volumes:
- ./certs:/etc/ssl/certs # if mounting TLS certscall- Copy code
import os
import asyncio
from livekit import api
from livekit.api import (
CreateSIPInboundTrunkRequest, SIPInboundTrunkInfo,
CreateSIPDispatchRuleRequest, SIPDispatchRule, SIPDispatchRuleIndividual,
ListSIPInboundTrunkRequest, ListSIPDispatchRuleRequest,
)
async def setup_inbound_trunk():
lk = api.LiveKitAPI(
url=os.environ["LIVEKIT_URL"],
api_key=os.environ["LIVEKIT_API_KEY"],
api_secret=os.environ["LIVEKIT_API_SECRET"],
)
phone_number = os.environ["PHONE_NUMBER"] # e.g. "+1234567890"
provider_ip = os.environ.get("SIP_PROVIDER_IP") # optional
# Check existing trunks
existing = await lk.sip.list_sip_inbound_trunk(ListSIPInboundTrunkRequest())
trunk = None
for t in existing.items:
if phone_number in (t.numbers or []):
trunk = t
print("Found existing trunk:", trunk.sip_trunk_id)
break
if trunk is None:
trunk_req = CreateSIPInboundTrunkRequest(
trunk=SIPInboundTrunkInfo(
name="vm-inbound-trunk",
numbers=[phone_number],
krisp_enabled=True,
# allowed_addresses=[provider_ip] if provider_ip else None
)
)
trunk = await lk.sip.create_sip_inbound_trunk(trunk_req)
print("Created trunk id:", trunk.sip_trunk_id)
# Create or find dispatch rule attached to this trunk
existing_rules = await lk.sip.list_sip_dispatch_rule(ListSIPDispatchRuleRequest())
rule = None
for r in existing_rules.items:
if trunk.sip_trunk_id in (r.trunk_ids or []):
rule = r
print("Found existing dispatch rule:", r.sip_dispatch_rule_id)
break
if rule is None:
dispatch_req = CreateSIPDispatchRuleRequest(
trunk_ids=[trunk.sip_trunk_id],
rule=SIPDispatchRule(
dispatch_rule_individual=SIPDispatchRuleIndividual(room_prefix="call")
),
)
rule = await lk.sip.create_sip_dispatch_rule(dispatch_req)
print("Created dispatch rule id:", rule.sip_dispatch_rule_id)
print("\nSave these values into your .env or secrets store:")
print("SIP_INBOUND_TRUNK_ID=", trunk.sip_trunk_id)
print("SIP_DISPATCH_RULE_ID=", rule.sip_dispatch_rule_id)
if __name__ == "__main__":
asyncio.run(setup_inbound_trunk())8 Views