Self-Host a Packet Loss Test Server (Free & Open Source)

Run your own OpenPacketLoss™ Server on hardware you control to test packet loss, jitter, and latency across your LAN, Wi-Fi, or WAN path without relying on a public endpoint. Hosting locally lets you pinpoint internal network bottlenecks and troubleshoot connectivity even if your internet goes down, all while keeping your data entirely private. Because you aren't relying on outside infrastructure, you know for a fact that external routing issues or overloaded third-party servers won't skew your results.

Whether you download it from an app store, deploy a native desktop package, or spin up a container, the server works exactly the same across phones, tablets, desktops, and self-hosted lab environments.

App Stores

Use the native store packages if you want the fastest setup path on Apple, Android, Windows, or Linux devices, with automatic updates available through the platform store.

Apple App Store iPhone and iPad Mac App Store macOS Google Play Android Microsoft Store Windows Snapcraft Linux app store package

Desktop Applications

Get the standalone OpenPacketLoss™ Server for your environment. These native builds are optimized for high-performance network testing and integrate seamlessly with your operating system.

Containers

Ideally suited for servers, NAS devices (Unraid, Synology), and automated lab environments. We provide native multi-architecture support for modern hardware:

linux/amd64: Standard Intel/AMD servers and Cloud VMs.
linux/arm64: Raspberry Pi 4/5, AWS Graviton, and Apple Silicon.
linux/arm/v7: Raspberry Pi 3 and compatible boards.

Quick Start (Host Networking)

For a quick deployment, use the following command:

Warning: Host Networking

Host networking (--network host) provides the best performance and simplified WebRTC setup, but it is primarily supported on Linux. It will not work as expected on Docker Desktop for Windows or macOS due to how the virtualization layer handles network stacks.

docker run -d \
  --name openpacketloss \
  --network host \
  --restart unless-stopped \
  openpacketloss/openpacketloss-server:latest

Docker Compose (Recommended)

For structured deployments and easier management, use the following docker-compose.yml configuration:

Option A: Host Networking (Best for Linux)

services:
  openpacketloss:
    image: openpacketloss/openpacketloss-server:latest
    container_name: openpacketloss
    network_mode: host
    restart: unless-stopped
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

Deploy: docker compose up -d | Access: http://YOUR-SERVER-IP:80

Option B: Bridge Mode (Universal / Non-Host)

Use this configuration if you are running on Windows/macOS, or if you prefer to avoid host networking on Linux (e.g., for security or explicit port isolation). This mode works across all platforms.

A range of 50 ports (e.g., 40000-40050) is typically enough for small-scale or personal use, supporting around 25–50 concurrent users. However, for production or public-facing servers, we recommend using a wider range (such as the standard ephemeral range 49152-65535) to avoid port exhaustion during peak usage.

services:
  openpacketloss:
    image: openpacketloss/openpacketloss-server:latest
    container_name: openpacketloss
    restart: unless-stopped

    ports:
      # HTTP and API mapping
      - "9000:80"
      - "4000:4000/udp"

      # WebRTC ICE UDP port range
      - "40000-40050:40000-40050/udp"

    environment:
      # --- Networking (required) ---
      - STUN_PORT=4000
      - NAT_1TO1_IP=192.168.1.12

      # --- WebRTC ICE Port Range ---
      - ICE_PORT_MIN=40000
      - ICE_PORT_MAX=40050

    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

Deploy: docker compose up -d | Access: http://YOUR-SERVER-IP:9000

Deployment Configuration

Webapp: Port 9000
STUN Server: Port 4000 (UDP)
WebRTC Media: 40000-40050 (UDP)
External IP: Ensure NAT_1TO1_IP and the Host IP are updated in the configuration before deploying.

Monitor Logs: docker logs -f openpacketloss

Network Configuration

When deploying in cloud environments (e.g., AWS, Azure, GCP, DigitalOcean), you must manually open these ports in your Security Group or Firewall. Host networking bypasses Docker's internal NAT, but it does not bypass your provider's external firewall.

IMPORTANT: Cloud Firewalls

If you are using a Cloud Provider, the server will not be reachable until you explicitly permit incoming traffic on the ports listed below. Failure to open the UDP range will result in ICE Connection Failures.

Required Ports

Port / Range	Protocol	Purpose
`80`	TCP	Web Frontend & API Signaling
`3478`	UDP	Integrated STUN Server
`49152 - 65535`	UDP	WebRTC Data Stream (Standard Ephemeral Range). Recommended for production. For small-scale use, a restricted range like `40000-40050` is sufficient.

Option B: If using Bridge Mode, ensure you open the specific ports mapped to your host (e.g., 9000, 4000, and 40000-40050 UDP) in your firewall instead of the default ports listed above.

Environment Variables

Configure your server by passing these environment variables to the Docker container or setting them in your .env file.

Server Configuration Options

Variable	Default	Description
`PLATFORM_MODE`	`self`	'web' (public service) or 'self' (self-hosted with flexible limits).
`PORT`	`80`	HTTP server port for signaling.
`STUN_PORT`	`3478`	Built-in STUN server UDP port.
`STUN_URL`	`auto`	STUN URL (`auto`, explicit `stun:ip:port`, or `none`).
`NAT_1TO1_IP`	-	Public/External IP for NAT environments (SDP mangling). Auto-detects LAN IP if empty.
`MAX_CONNECTIONS`	`500`	Maximum total concurrent connections.
`MAX_CONNECTIONS_PER_IP`	`10`	Maximum concurrent connections per unique client IP.
`ICE_PORT_MIN`	-	Minimum UDP port for WebRTC ICE candidates (optional).
`ICE_PORT_MAX`	-	Maximum UDP port for WebRTC ICE candidates (optional).
`ICE_GATHERING_TIMEOUT_SECS`	`2`	Seconds to wait for ICE candidate gathering.
`OVERALL_REQUEST_TIMEOUT_SECS`	`30`	Maximum time for the entire SDP handshake process.
`STALE_CONNECTION_AGE_SECS`	`120`	Maximum age in seconds for inactive connections.
`PERIODIC_CLEANUP_INTERVAL_SECS`	`5`	Interval to scan and clean up stale connections.
`RUST_LOG`	`info`	Logging verbosity (trace, debug, info, warn, error).

Docker Hub View image on Registry GitHub: Server Source code & native builds GitHub: Docker Dockerfile & Compose source GitHub: UI Frontend source code

What is Packet Loss? Deep dive into the causes and technical impacts of data loss. How to Fix Packet Loss Step-by-step troubleshooting guide to resolve network instability. FAQ & Troubleshooting Common error codes and WebRTC connection fixes.

Recommended Deployment Paths

Home users & Gamers: Install from the official stores (Apple, Google, Microsoft) for the easiest setup and automatic updates.
Lab & Edge Infrastructure: Use Docker for repeatable deployments, easy versioning, and minimal host OS clutter.
Linux Power Users: Choose between Snap, Flatpak, or native DEB/RPM packages based on your distribution's package management preference.