Routr is a lightweight sip proxy, location server, and registrar that provides a reliable and scalable SIP infrastructure for telephony carriers, communication service providers, and integrators.
- Community
- Should you try Routr?
- Contact us
- Features
- The official handbook
- Deployment
- Getting started with the CTL
- First steps with the NodeSDK
- Custom Processors and Middleware
- Documentation
- Bugs and feedback
- Sponsors
- Contributing
- License
We are building Routr in the open. The best to communicate with us is via GitHub Discussions. You can also join our Discord server to discuss roadmaps, feature requests, and more.
Routr's architecture and design is fantastic. A breath of fresh air. Being Docker and Kubernetes ready is a huge win over a more traditional SIP server setup.
Phil Jones, VP of Web Architecture at VQ Communications
I came across Routr, which seems to be the one and only cloud-first Kubernetes-ready SIP server on the planet!
Jessie Wadman, Cloud Architect @ Camanio AB
Awesome and one of the best open-source software in 2023.
no-championship-s368, Check conversation @ Reddit
I think this project has a great promise to become a transformative technology.
jbwill36, Check conversation @ GitHub
Meet our sales team for any commercial inquiries.
Routr's main features are:
- Common SIP Server functions; Proxy, Registrar, Location Service
- Programmable routing
- Load balancing strategies against Media Servers like Asterisk and FreeSWITCH
- Session Affinity
- Multi-Tenant/Multi-Domain with Domain level Access Control List
- Region-based routing
- Configurable routing strategies; Intra-Domain, Domain Ingress, Domain Egress, and Peer Egress
- No single point of failure
- Transport: TCP, UDP, TLS, WS, WSS
- In-memory and Redis Location Service
- JSON and YAML files as a data source
- Postgres as a data source
- Server management with the gRPC API
- NodeSDK
- Command-Line Tool
- RTPEngine Middleware
- Helm Chart for Kubernetes Deployments
- Endpoint Authentication with JWT (For web phones)
- SDES-SRTP media toward TLS trunks (with RTPEngine)
- Call message recording and replay
- OpenTelemetry traces, metrics, and logs
- Support for STIR/SHAKEN
- Web Application
To learn more, read the documentation 📚
This handbook offers a detailed information about of the innovative features, challenges, and opportunities associated with using Routr.
Get the eBook.
If you want to support this project, please give it a star. Thanks 🙏
Routr 3 reads its settings from one file, routr.yaml. Create a directory named "routr", navigate into it, and add these two files.
Filename: routr.yaml
apiVersion: v3
kind: Routr
ref: routr-one
spec:
edgeport:
externalAddrs:
- "${DOCKER_HOST_ADDRESS}"
transport:
- protocol: udp
port: 5060
- protocol: tcp
port: 5060
data:
backend: postgres
url: secret://env/DATABASE_URL
apiKeys:
- secret://env/ROUTR_API_KEYFilename: compose.yaml
services:
postgres:
image: postgres:16-alpine
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: routr
healthcheck:
test: ["CMD", "pg_isready", "-U", "postgres"]
interval: 2s
retries: 30
volumes:
- db:/var/lib/postgresql/data
migrations:
image: fonoster/routr-pgdata-migrations:latest
environment:
DATABASE_URL: postgresql://postgres:postgres@postgres:5432/routr?schema=public
depends_on:
postgres:
condition: service_healthy
routr:
image: fonoster/routr-one:latest
environment:
DATABASE_URL: postgresql://postgres:postgres@postgres:5432/routr?schema=public
ROUTR_API_KEY: ${ROUTR_API_KEY}
DOCKER_HOST_ADDRESS: ${DOCKER_HOST_ADDRESS}
ports:
- 51907:51907
- 5060:5060/udp
- 5060:5060/tcp
volumes:
- ./routr.yaml:/etc/routr/routr.yaml:ro
depends_on:
migrations:
condition: service_completed_successfully
volumes:
db:Then, generate an API key and start the server:
# Be sure to replace with your IP address
export ROUTR_API_KEY=$(openssl rand -hex 32)
DOCKER_HOST_ADDRESS=192.168.1.3 docker compose up -dThe Data API, which rctl and the SDK reach on port 51907, refuses to start without the key. Every key of routr.yaml is in the configuration reference. Upgrading from Routr 2? See the upgrade guide.
Afterward, you can verify the status of the containers using:
docker ps -a --format 'table {{.ID}}\t{{.Image}}\t{{.Status}}'If the routr container's status is "Up," you are ready to go.
Routr can be installed in Kubernetes using Helm. The following instructions assume that you have a Kubernetes cluster up and running.
You can use Minikube or Docker Desktop to create a local Kubernetes cluster.
First, add the Helm repository:
helm repo add routr https://routr.io/charts
helm repo updateThen, create a namespace for Routr:
kubectl create namespace routrNext, install Routr with the following command:
helm install my-release routr/routr-connect --namespace routrFinally, wait a few minutes for the pods to start. You can check the status of the pods with the following command:
kubectl get pods -n routrYou should see a list of pods and their status. If the status is Running, then you are ready to go.
For more details, please refer to the chart's README.
Regardless of the deployment method, you can use the command-line tool to manage your server.
To install the command-line tool, run the following command:
npm install --location=global @routr/ctlWe are using the flag --location=global to tell npm to install the command-line tool globally. If you don't have npm installed, you can follow the instructions here: https://nodejs.org/en/download/.
rctl reads the API key from ROUTR_API_KEY. Here is an example of how to create a domain against the Docker setup above:
rctl domains create --endpoint localhost:51907 --insecureThe --insecure flag is required because the Data API in that setup has no TLS. On Kubernetes, the chart turns TLS on and prints the commands that fetch the key and the CA certificate after the install.
Follow the prompts to create the domain.
The output should look like this:
This utility will help you create a new Domain.
Press ^C at any time to quit.
? Friendly Name Local Domain
? SIP URI sip.local
? IP Access Control List None
? Ready? Yes
Creating Domain Local Domain... a27e9fb2-a71a-4cf3-9b1d-dccf373f9777For additional examples, refer to the command line documentation.
To begin using the Node.js SDK, first make sure you have Node and NPM installed. Then, start by creating a new project and installing the Routr Connect SDK.
mkdir my-project
cd my-project
npm init -yNext, install the SDK:
npm install --save @routr/sdkNow, create a new file called index.js and add the following code:
const SDK = require("@routr/sdk").default;
// The Docker setup above: the Data API on 51907, no TLS, the key from ROUTR_API_KEY
const domains = new SDK.Domains({
endpoint: "localhost:51907",
insecure: true,
apiKey: process.env.ROUTR_API_KEY
});
const request = {
name: "Local domain",
domainUri: "sip.local",
accessControlListRef: "4671371b-ff5d-48b1-aabe-d3c5ca5317a3",
egressPolicies: [{
rule: ".*",
numberRef: "4671371b-ff5d-48b1-aabe-d3c5ca5317a3"
}],
extended: {
"key": "value"
}
};
domains.createDomain(request)
.then(console.log)
.catch(console.error); // an error occurredIn the example above, we assume that the ACL and Number already exist.
Now, go ahead and run the code:
node index.jsFor complete documentation, please visit the npm page for @routr/sdk at https://www.npmjs.com/package/@routr/sdk
One of Routr's most significant advantages is that it is highly extensible. It enables you to create new Processors and Middleware to extend the functionality of your server.
Processors and Middleware services are responsible for modifying the SIP messages as they pass through the server. However, while both share the same interface, they serve different purposes.
Processors hold feature logic; Middlewares addresses cross-cutting concerns like authentication, authorization, rate limiting, etc.
The simplest possible Processor looks like this:
const Processor = require("@routr/processor").default
new Processor({ bindAddr: "0.0.0.0:51904", name: "echo" }).listen(
(req, res) => {
console.log("got new request: ")
console.log(JSON.stringify(req, null, " "))
res.sendOk()
}
)The previous example is for a Processor that waits for a SIP message and then sends a 200 OK response. You can find the complete code here.
The same Processor in Go, with the Go SDK (github.com/fonoster/routr/pkg/processor):
func main() {
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
err := processor.ListenAndServe(ctx, processor.Options{BindAddr: "0.0.0.0:51904", Name: "echo"},
func(ctx context.Context, req *processor.MessageRequest) (*processor.MessageResponse, error) {
return processor.OK(), nil
})
if err != nil {
log.Fatal(err)
}
}The complete code is in pkg/processor/examples/echo, and the Build a processor guide covers both languages.
In addition to the previous example, you can check the following modules:
For more information about building Processors and Middleware, please refer to the documentation.
Report bugs in GitHub Issues. For questions and feature ideas, use GitHub Discussions.
For contributing, please see the following links:
The repository includes a Dev Container with everything you need to build and run Routr: Node.js 22 and Go 1.26, the same versions CI uses.
To get started, open the repository in VS Code and run Dev Containers: Reopen in Container, or use the CLI:
npx @devcontainers/cli@latest up --workspace-folder .On first creation, the container generates the self-signed TLS certificate EdgePort expects and builds the project. The first build takes a while; later rebuilds reuse the cached node_modules and npm volumes.
Once it is ready, check the setup with the echo test. It starts the Go EdgePort, the Dispatcher and the Echo processor, sends a SIP MESSAGE, and expects a 200 OK, with no database involved:
npm run test:echoPostgres, Redis and RTPEngine are not started up front; start and stop them with npm run start:deps and npm run stop:deps. npm run start:one runs RoutrOne, every component in one process, on config/routr.yaml. npm start runs one process per component on the other files in config/, with the file-based API server on config/resources.
The SIP ports (5060-5063) and the service ports (51901, 51902, 51904, 51907 and 51908) are forwarded to your machine.
Note
VS Code only forwards TCP ports, so SIP over UDP from a softphone on your host will not reach the container. Use TCP or WebSocket instead.
|
Pedro Sanders |
Efrain Peralta |
Vikas Prasad |
vitalyster |
Hannarong |
rafasc |
|
Kani |
Martin Matyáš |
SemiConscious |
Timmy |
luzpaz |
We're glad to be supported by respected companies and individuals from several industries.
Find all our supporters here
Copyright (C) 2026 by Fonoster Inc. MIT License (see LICENSE for details).