Tagged: SIP

Single-box PBX is easy. The hard part starts when you run two nodes and discover that “shared database” doesn’t make phones work together: a call lives on exactly one node, registrations land wherever the load balancer sends them, and the console you’re logged into may have no idea that the extension you want to transfer is being served by its neighbor.

RustPBX 0.5 closes that gap with a distributed session registry. Here’s what it changes in practice.

Interconnecting with carriers is where good PBX software meets bad SIP. The other end has opinions: it rewrites numbers, rejects your codec order, sends private IPs in SDP, and insists on headers you’ve never heard of. A session border controller exists to absorb that.

The media plane is where a telephony platform earns its keep: pick the right codec, decide what gets transcoded, and manage every sound callers hear. RustPBX’s media engine is shared by SIP, WebRTC, queues, IVR, and recording — one pipeline, one set of behaviors.

“Outbound calls have no audio, inbound is fine.” If you’ve run SIP for a week, you’ve met this sentence. It’s almost never the codec — it’s address advertisement: the PBX told the far end an IP it can’t reach.

RustPBX separates the three addresses that SIP/WebRTC care about, and lets you override each per deployment, per network profile, or per trunk.

Every business hits the same requirement in week one: calls arriving outside business hours need a story. Not a busy tone, not an infinite ring — a story. Maybe a voicemail box, maybe an emergency escalation for VIPs, maybe a “we’re closed, back at 9” prompt in three languages.

This post walks through the patterns RustPBX gives you for after-hours handling, from the simple to the fairly sophisticated.

This is part of a Basics series covering the everyday tasks of running a RustPBX instance. Start here: create extensions, get devices registered, and understand the options you’ll actually use.

A PBX with a public IP gets scanned within minutes of going live. SipVicious and its cousins register-probe every open 5060 on the internet, hunting for default passwords they can turn into toll-fraud. Here’s the hardening checklist for the first 48 hours — all of it built in, none of it requiring external tooling.

A call detail record is only as useful as the questions it can answer. “Who called whom, when, and how long” is table stakes. The questions that actually matter at 2 AM are: why did it fail, which route did it take, was the audio bad on our side or the carrier’s, and did it transfer, and where. RustPBX CDRs are built to answer those without opening a PCAP.

Call forwarding is the most-requested feature after basic calling, and the one with the most edge cases: what counts as “busy”? What if the destination is another extension? What if the carrier rejects the forwarded leg? Here’s how RustPBX handles all of it.

Three months of steady work went into RustPBX 0.5 — roughly two thousand commits since the 0.4.x series. The theme across all of them: when something goes wrong mid-call, the platform should already know why. This post walks through the changes that matter most for anyone running RustPBX in production, from a single box to a multi-node cluster.

Wholesale voice is a business run on spreadsheets and margins, so the platform running it should speak spreadsheet: exact route matches, predictable rounding, and a way to answer “why did this call route the way it did” without guesswork. The latest RustPBX wholesale addon update focuses on exactly that.

Debugging SIP calls usually means running tcpdump, downloading PCAP files, and opening Wireshark. It works, but it’s slow, requires server access, and doesn’t scale.

SipFlow is RustPBX’s built-in signaling capture system. It records every SIP message and RTP packet, stores them efficiently, and presents a visual timeline in the web console. Need a recording? Generate a WAV from the captured RTP data with one click. Need to debug a call from last week? Query it by call ID.

And when a single node isn’t enough, SipFlow supports cluster deployment with consistent hashing.

Running a telephony platform isn’t just about connecting calls. Day-to-day operations involve renewing TLS certificates before they expire, archiving old call records so the database doesn’t grow forever, and transcribing recordings for quality audits.

RustPBX bundles three addons that handle these chores automatically. Here’s how each one works.

Ride-hailing apps, delivery platforms, and marketplaces all share a common requirement: connect two parties on a phone call without revealing their real numbers. This is the classic privacy number (AX/NXA) use case.

RustPBX’s SBC addon includes a JSON-RPC router that makes this straightforward. Every incoming call can query your backend API, get the real destination, rewrite the numbers, and connect the call – all in real time.

Your team can call each other internally. Now you need to connect to the PSTN through a carrier, let customers call in from web browsers, and manage it all without spinning up a separate SBC appliance.

RustPBX’s SBC addon handles this in a single runtime – no Janus, no FreeSWITCH, no extra media servers.

Every PBX starts with the same basic need: let people inside the organization call each other. Whether your team uses desk phones, softphones, or web browsers, it all comes down to configuring extensions and getting them registered.

This post walks through setting up internal VoIP communication in RustPBX from scratch, using its web console.