Sidetone

A SIP softphone built for troubleshooting: place the call, see the ladder, and know why it failed.
Test calls over UDP, TCP, TLS or WebRTC, SRTP included, pcap and pcapng analysis, RTP quality and MOS, plain-language diagnostics,
an AI second opinion with your own keys, automated test suites and an MCP server, for Windows, macOS, Linux and the browser.

Download · Open it in the browser · Test suite examples · Contribute

_{Alpha: expect rough edges. A capture that Sidetone reads wrong or a finding that misleads? Open an issue with a redacted pcapng (Export › Redacted pcapng): real traces are what improve the rules most.}

_{Three lines, two of them in a local conference, Opus on the wire, BLF lamps, every event and result in plain words.}

Features · Everything in the box · Automation · AI · Under the hood · Get started · Help wanted · Downloads

Every screenshot is Sidetone itself, captured headless by scripts/readme-shots.mjs against the throwaway PBX in lab/ and the built-in sample captures, with a test tone instead of a microphone. Some are in the dark theme (the Theme button, or your system setting).

The live SIP trace: every request and response as it happens. See the wire while you talk Each message the phone sends or receives appears at once with its time, direction and peer; responses are coloured by class. Filter by number, method or Call-ID, hide the REGISTER and OPTIONS noise, pause, save the session as pcapng, or open it in the analyzer with one click.	A remote worker behind NAT: 200 OK retransmitted ten times, no ACK, drop at 32 s. The ladder, with the diagnosis on it Calls you make are captured and analyzed with the same engine as any pcap or pcapng from Wireshark, tcpdump, sngrep or an SBC. Dialogs are grouped by Call-ID; the ladder marks retransmissions and colours each response class; a dot shows which messages a finding points to.
The INVITE that started it: private Contact and private SDP address. About 40 rules that explain the call Missing ACK, NAT in SDP, one-way audio, codec mismatch, failed authentication, glare, session timer expiry, loss and jitter: each finding says what happened in words, with the message numbers as evidence.	Both directions of a bad call: loss, jitter, a 1.5 s gap and MOS below 3. Media you can measure Each RTP stream is tied to its call through the SDP: codec, packets, loss, RFC 3550 jitter, the longest gap, ptime, RFC 4733 digits and an ITU-T G.107 E-model MOS estimate. Per-second charts show jitter, loss and MOS over the call with the SIP events marked; RTCP sender and receiver reports (RFC 3550), RTCP XR VoIP metrics (RFC 3611) and vq-rtcpxr PUBLISH reports (RFC 6035) add what the far end measured, including round trip time; G.711 streams also get level, silence and clipping. Calls of the same session on both sides of an SBC or B2BUA are linked by X-CID, Session-ID and similar headers. MOS is also worked out through a fixed 50 ms, a fixed 200 ms and an adaptive jitter buffer, where a packet that arrives too late counts as lost. HEP (Homer) packets in a capture are unwrapped, the phone can send a HEPv3 copy of every SIP message to a Homer collector, and SRTP calls can be saved with the media decrypted. The ladder can show time since the start, since the row above or as clock time, and fold retransmissions into the arrow they repeat.
Per-account media: Opus and G.711 in your order, SRTP off, optional or required, with SDES or DTLS-SRTP keys. Every knob a desk phone has, and a preview Per account: UDP, TCP or TLS, outbound proxy, expiry and retry, keepalives, local IP and port, rport, symmetric RTP, RTP ports, DSCP, SDP address override, T1, codec order (Opus, PCMU, PCMA), SRTP, ptime, DTMF mode and payload type, session timers, user=phone, compact headers, PRACK, GRUU, long Contact, extra headers, BLF extensions, and a preview of the INVITE they produce. Some exist to reproduce a broken client on purpose, like skipping the ACK.	Reachability, DNS, NAT and audio checks in one place. Diagnostics before the call OPTIONS ping with round trip and server agent, RFC 3263 lookups (NAPTR, SRV for UDP, TCP and TLS, A/AAAA), STUN against two servers to spot a symmetric NAT, the address each registrar sees you from, a microphone and speaker test with level meters, and a live capture on any network interface for traffic that is not the phone's own.
Ask AI, with "Show what will be sent" before anything leaves. An AI second opinion An AI panel docked under any page lets you hold a conversation about the selected call, the live trace or a capture: the model gets the findings, the ladder, the RTP statistics and the relevant raw messages, masked by default. Configure it once in Settings, AI: Anthropic, any OpenAI-compatible service (OpenAI, Gemini, OpenRouter, Groq, Mistral, DeepSeek, LM Studio, vLLM) or a local Ollama, with a connection test.	No install: the browser version on GitHub Pages, calling over WebRTC. The same phone in the browser On GitHub Pages Sidetone talks SIP over WebSocket (RFC 7118) with WebRTC audio, so it reaches any PBX or SBC with a WSS listener. Several lines with automatic hold and call waiting, mute, blind and attended transfer, a three-way conference mixed with Web Audio, and DTMF; analysis runs in the page through WebAssembly.
The interface and the built-in help in Portuguese. Your language, with help built in English, Portuguese (Brazil), Spanish, German, French, Chinese (Simplified) and Hindi, switched in Settings or on the Help page. Findings and explanations are translated too; SIP messages and traces stay as they were on the wire, so what you paste into a ticket reads the same for everyone. Help covers accounts, calls, transfers, TCP/TLS, SRTP, BLF, conference, analysis and common problems.

The CLI and the web app share one engine, so anything the window does, a script does too.

# Read a capture: calls, ladder, RTP, findings
sidetone analyze trace.pcapng --ladder
sidetone analyze trace.pcapng --call 3 --svg call3.svg
sidetone analyze trace.pcapng --json > report.json

# Share it: findings as Wireshark comments, or masked for a vendor ticket
sidetone export trace.pcapng -o annotated.pcapng
sidetone export trace.pcapng -o share.pcapng --call 3 --redact

# Be a Homer collector: receive HEPv3 from Kamailio, OpenSIPS, FreeSWITCH
# or heplify, save it, and analyze it like any capture
sidetone hep --listen 0.0.0.0:9060 -o hep.pcapng

# Place calls from a script, then read what happened
sidetone call 600 --domain pbx.lab:5060 --user 2001 --password "$PW" \
  --register --dtmf 123# --pcap call.pcapng --wav call.wav
sidetone answer --domain pbx.lab --user 3001 --password "$PW" --register --audio echo
sidetone options pbx.lab

Test suites are JSON: cases made of register, options, call, wait and unregister steps, each with expectations (final status, maximum errors, minimum MOS, loss, jitter, post-dial delay, talk time, codec, RTP received, rules that must or must not appear). Each case saves its pcapng.

SIP_PASSWORD=... sidetone test examples/asterisk-lab.suite.json --junit junit.xml
sidetone test suite.json --ai-explain     # failed cases get an AI explanation
sidetone test-gen "register 2001 on pbx.lab and check echo 600 with DTMF and MOS above 4" -o new.suite.json

{ "name": "echo test with DTMF",
  "steps": [ { "call": { "target": "600", "duration": 4, "dtmf": "123#",
      "expect": { "status": 200, "min_mos": 4.0, "rtp_received": true,
                  "rules_present": ["rtp.dtmf"], "rules_absent": ["rtp.one_way"] } } } ] }

Serve the analyzer and the phone to an AI agent over the Model Context Protocol:

{ "mcpServers": { "sidetone": { "command": "/path/to/sidetone", "args": ["mcp"] } } }

Sidetone has no AI of its own and no account. Detection is deterministic; the model is only asked to interpret, which keeps answers grounded and cheap. Pick Anthropic, any OpenAI-compatible endpoint (a gateway, LM Studio, vLLM) or a local Ollama; nothing is sent until you ask, masking is on by default, and "Show what will be sent" prints the exact prompt.

export ANTHROPIC_API_KEY=...
sidetone ai trace.pcapng --call 2 --lang "Portuguese (Brazil)"
sidetone ai trace.pcapng --provider ollama --model llama3.1
sidetone ai trace.pcapng --dry-run

In the browser the key stays in that browser and goes only to the provider; Ollama needs OLLAMA_ORIGINS to include the page origin.

• Engine first: crates/sidetone-core holds capture I/O, SIP/SDP/RTP parsing, call correlation, the rules, the ladder, export, redaction and the AI prompt, with no network or audio code, so it runs natively and as WebAssembly.
• One frontend, three homes: web/ runs on GitHub Pages with the analyzer in WASM, behind sidetone serve, and inside the Tauri desktop app, which starts the local server on a random loopback port protected by a per-launch token.
• A phone engine, not a script: crates/sidetone-ua runs one signaling thread with RFC 3261 client transactions and timers, dialogs, re-INVITE, REFER/NOTIFY and Replaces, and a media thread pair per line; the UI drives it through a small HTTP API and reads snapshots, events and the trace. Accounts, settings and history live in your user configuration folder (SIDETONE_CONFIG_DIR overrides it).
• Capture without drivers: the phone records its own datagrams with real addresses and timestamps, so no Npcap, libpcap or root is needed.
• The interface the OS would use: the local address comes from the route to the server, so a VPN or virtual adapter does not end up in Via, Contact and SDP.
• Tested against a real PBX: CI runs unit tests on Linux, Windows and macOS, builds the WASM, starts Asterisk from lab/, runs the example suite, drives the phone engine through calls, hold, DTMF, both kinds of transfer, DND and auto answer, and opens every exported capture with tshark.

git clone https://github.com/igtoth/sidetone
cd sidetone
cargo run --release -p sidetone-cli -- serve      # phone and analyzer on http://127.0.0.1:8640
cargo run --release -p sidetone-cli -- samples ./samples
cargo test --workspace --exclude sidetone-desktop

A recent stable Rust (CI uses stable). The desktop app builds with npx @tauri-apps/cli@2 build in app/; on Linux it needs WebKitGTK 4.1. For a local PBX to call: lab/run-asterisk.sh (Asterisk on UDP, TCP, TLS and WebSocket, with SDES and DTLS-SRTP users, a WebRTC user, BLF and presence hints, echo, busy and unallocated numbers).

Sidetone can load account settings from a small XML file served over HTTP(S). In Settings, open an account and press Provision, then paste the URL. A valid file is saved and the account registers. Besides its own strict format, the desktop app reads the Yealink .cfg, Polycom XML and Cisco SEP<MAC>.cnf.xml files a PBX already serves to desk phones (the first configured line becomes the account), over HTTP, HTTPS or TFTP, with {mac} in the URL filled with the device MAC. It can ask DHCP for the server phones are given (options 66, 150, 160), Diagnostics fetches what a phone with a given MAC would get, and Analysis explains DHCP and TFTP in a capture of a phone booting. Every key, the vendor mappings, the samples and the resync rules are in docs/provisioning.md. To back up or move the whole configuration instead, use Settings, Import and export (one JSON file, from a file or a URL).

Example (sidetone-provision version 1; display_name is required):

<?xml version="1.0" encoding="UTF-8"?>
<sidetone-provision version="1">
  <account.1.user>2001</account.1.user>
  <account.1.display_name>Lab 2001</account.1.display_name>
  <account.1.domain>pbx.example.com</account.1.domain>
  <account.1.password>secret</account.1.password>
  <account.1.transport>udp</account.1.transport>
</sidetone-provision>

Browser accounts also need account.1.ws and usually account.1.ice.

When the registrar sends SIP NOTIFY with Event: check-sync or Event: resync, Sidetone re-downloads the stored provisioning URL for that account. If Accept requests only from the registrar is on, check-sync applies only when the NOTIFY comes from the registrar. A resync during a call is deferred until that account's last call ends; if a new call starts while the file is downloading, apply waits again. Downloads for the same account are at least 10 seconds apart, measured from the start of the last attempt.

The desktop app fetches provisioning URLs directly (it does not use HTTPS_PROXY). TLS is checked against public roots unless you turn off Check the server's TLS certificate in the provision dialog; the browser phone always uses the browser's TLS rules and cannot disable verification. An HTTPS-hosted page cannot fetch an http:// provisioning URL (mixed content); use the desktop app for a LAN HTTP server.

In the browser, account.1.remember_password set to 0 keeps the password only until you reload the page (unless you save with remember enabled in Settings).

• Try it on your own traces. A capture Sidetone reads wrong, or a finding that misleads, sent as a redacted pcapng in an issue, improves the rules more than anything else.
• Write a rule. Each rule is a few lines in crates/sidetone-core/src/rules.rs plus a synthetic scenario in synth.rs that proves it.
• Share a test suite for your PBX, SBC or carrier in examples/.
• Package it for the system you use (Homebrew, winget, AUR, Flatpak).

Each version gets a release with installers for every platform: take the latest release, or pick a file below (version 0.1.25).

Portable and standalone. Nothing has to be installed:

• Windows: unzip Sidetone_..._portable.zip anywhere (a USB stick works) and run Sidetone.exe. It uses the WebView2 that comes with Windows 10 and 11.
• macOS: unpack Sidetone_....app.tar.gz and open Sidetone.app from any folder.
• Linux: chmod +x the AppImage and run it. On distributions without FUSE 2, run it with --appimage-extract-and-run.
• Command line, any platform: a single executable with the interface built in. Double click sidetone (or run it with no arguments) and the full app opens in your browser, with no WebView or system library needed. Closing its window stops it. sidetone serve --open does the same from a terminal.

Settings, accounts and history live in your user configuration folder in every form, so you can switch between them. To keep everything with the program instead (a USB stick, say), create a folder named sidetone-data next to the executable, or set SIDETONE_CONFIG_DIR.

Windows. Run the .exe installer (or the .msi for managed deployments). The downloads are not code-signed yet: if SmartScreen warns, choose More info › Run anyway. Allow Sidetone through Windows Firewall when asked, or incoming calls cannot reach it.

macOS. Open the .dmg and drag Sidetone to Applications. The app is not signed yet, so the first time right-click it and choose Open (or run xattr -dr com.apple.quarantine /Applications/Sidetone.app). macOS asks for microphone access on the first call.

Linux. Debian and Ubuntu: sudo apt install ./Sidetone_0.1.25_amd64.deb. Fedora and openSUSE: sudo dnf install ./Sidetone-0.1.25-1.x86_64.rpm. Anywhere else: chmod +x Sidetone_0.1.25_amd64.AppImage and run it. The desktop app needs WebKitGTK 4.1 (present on current distributions).

Command line. Unpack the archive and put sidetone on your PATH:

tar xzf sidetone-v0.1.25-x86_64-unknown-linux-gnu.tar.gz
sudo install sidetone-v0.1.25-x86_64-unknown-linux-gnu/sidetone /usr/local/bin/
sidetone              # the full app in your browser (same as sidetone serve --open)

On macOS remove the quarantine flag first (xattr -d com.apple.quarantine sidetone). The archive also has the example test suites.

Capturing other hosts' traffic (Diagnostics, Capture on an interface) needs a packet capture library and the right to use it. Windows: install Npcap (Wireshark installs it). macOS: libpcap is built in; install Wireshark's ChmodBPF or run as root. Linux: libpcap is usually installed; give the binary the capability once with sudo setcap cap_net_raw,cap_net_admin=eip /usr/bin/sidetone-desktop (or the sidetone CLI), or run it with sudo. Everything else works without it.

From source. See Get started.

Sidetone is licensed under the MIT License. Copyright © 2026 Ighor Toth.

Written by Ighor Toth with Claude Code, Anthropic's AI coding assistant, as co-author: commits it helped write carry a Co-Authored-By line.

Codecs: G.722 from libg722 (Steve Underwood, public domain, and CMU) through the ezk-g722 translation (MIT); G.726 from soundkit-g726 (MIT); GSM 06.10 from libgsm (Jutta Degener and Carsten Bormann, TU Berlin); Speex from libspeex (Xiph.Org, BSD) and iLBC from WebRTC (BSD), both bundled in crates/sidetone-ua/native with their licences; G.729 from the g729-sys crate, which describes itself as MIT but is a port of bcg729 (GPL-3.0): builds that must avoid GPL code can leave it out.

The interface uses IBM Plex Sans and IBM Plex Mono (SIL Open Font License), loaded from Google Fonts. Every capture in the screenshots and samples was made for Sidetone.

_{Sidetone is an independent open-source project, not affiliated with, sponsored by or endorsed by any other software vendor. Product names such as Wireshark and Asterisk belong to their owners and are used only to describe compatibility. The software is provided "as is", without warranty of any kind, as the license states.}