Rdio Scanner: The Revolutionary SDR Audio Distribution System

Transform your software-defined radio workflow with this powerful, modern audio ingestion platform that brings police scanner nostalgia to the digital age.

Are you drowning in a sea of disconnected audio files from your SDR setup? Struggling to distribute radio transmissions across your team or community? Rdio Scanner eliminates the chaos. This open-source powerhouse ingests audio from multiple SDR recorders and delivers it through a sleek, web-based interface that mimics the intuitive experience of traditional police scanners—while adding cutting-edge features modern users demand. In this deep dive, you'll discover everything from installation to advanced configuration, real-world deployments, and pro tips that will revolutionize your radio monitoring workflow.

What is Rdio Scanner?

Rdio Scanner is an innovative open-source software solution engineered to ingest and distribute audio files generated by various software-defined radio (SDR) recorders. Created by developer chuot, this tool addresses a critical gap in the SDR community: the need for a unified, user-friendly platform to manage, organize, and stream radio transmissions captured across different systems and protocols.

At its core, Rdio Scanner acts as a central nervous system for your SDR infrastructure. It monitors directories for new audio files, processes metadata, and instantly makes transmissions available through an integrated web application. The interface deliberately evokes the tactile experience of physical police scanners—complete with channel groups, priority settings, and real-time audio streaming—while layering on modern capabilities like mobile access, API integration, and Docker deployment.

Why it's trending now: The explosion of affordable SDR hardware (RTL-SDR, Airspy, SDRplay) has democratized radio monitoring, but software solutions remained fragmented. Rdio Scanner unifies this ecosystem, supporting popular recorders like Trunk Recorder, RTLSDR-Airband, SDRTrunk, voxcall, ProScan, and DSDPlus Fast Lane. Its meteoric rise in the SDR community stems from solving real pain points: multi-recorder management, remote access, and community sharing—making it indispensable for hobbyists, journalists, and public safety professionals alike.

Key Features That Set Rdio Scanner Apart

Universal Recorder Compatibility: Rdio Scanner's architecture embraces flexibility through two integration methods. The API method allows direct push from supported recorders, while Dirwatch continuously monitors specified folders for new audio files. This dual approach ensures compatibility with virtually any recorder that can output separate audio files per transmission.

Authentic Scanner Interface: The web application meticulously recreates the police scanner experience. Users enjoy channel grouping, priority channel management, hold/temporary hold functionality, and real-time signal strength indicators. This familiarity reduces the learning curve while enhancing operational efficiency.

Cross-Platform Distribution: Native applications for iOS and Android extend the experience beyond desktop browsers. Whether you're monitoring emergency services during a crisis or tracking aviation traffic from the field, Rdio Scanner keeps you connected on any device.

Docker-First Deployment: Every release includes an official Docker image, enabling containerized deployments that scale effortlessly. This modern approach simplifies installation, updates, and system resource management across Linux, Windows, and macOS hosts.

Advanced Audio Management: The system supports metadata ingestion (talkgroup IDs, frequencies, timestamps), automatic audio normalization, transmission deduplication, and intelligent buffering. These features ensure smooth playback and accurate record-keeping.

Multi-Tenancy Support: Configure multiple agencies, systems, or talkgroup collections within a single instance. Each user can customize their view, creating personalized monitoring environments without affecting others.

RESTful API & WebSocket Streaming: While the WebSocket API is restricted to official mobile apps, the REST API enables custom integrations, automation scripts, and third-party tool connectivity—opening endless possibilities for power users.

Real-World Use Cases: Where Rdio Scanner Shines

1. Emergency Services Monitoring for News Organizations Journalism teams covering breaking news need real-time access to police, fire, and EMS communications. Rdio Scanner allows newsrooms to deploy multiple SDR recorders across a metro area, ingest all transmissions centrally, and provide reporters with browser-based access to relevant channels. During major incidents, editors can prioritize specific talkgroups, share direct links to audio clips, and maintain historical archives for fact-checking—all without specialized hardware.

2. Aviation Hobbyist Communities Airband monitoring enthusiasts traditionally needed expensive receivers and complex setups. With Rdio Scanner, a single RTLSDR-Airband installation can capture multiple frequencies simultaneously, feeding audio to a community server. Members access the web interface to listen to tower, ground, and approach frequencies from anywhere, while the mobile app delivers push notifications when activity spikes on monitored channels.

3. Public Safety Agency Training & Review Fire departments and EMS agencies use trunked radio systems that generate thousands of daily transmissions. Rdio Scanner archives these automatically, creating a searchable database for training purposes. Instructors can isolate specific incidents, playback sequences for critique, and demonstrate proper radio discipline. The police scanner interface feels natural to first responders, accelerating adoption.

4. Ham Radio Emergency Preparedness Groups Amateur radio emergency service (ARES) groups prepare for disasters by monitoring local government frequencies. Rdio Scanner enables them to set up redundant recording stations, distribute feeds to net control operators remotely, and maintain logs for post-event analysis. During exercises, the Docker deployment allows rapid scaling to handle increased traffic, while API integration with alerting systems triggers notifications for critical transmissions.

5. Security Operations Centers Corporate security teams protecting large campuses or event venues monitor multiple radio systems (security, facilities, local law enforcement). Rdio Scanner consolidates these into a single pane of glass, allowing dispatchers to manage incidents efficiently. The ability to create custom channel groups for different shifts, locations, or event types transforms situational awareness.

Step-by-Step Installation & Setup Guide

Method 1: Precompiled Binary Installation

Step 1: Download the Latest Release Always fetch the newest version from the official repository. Visit https://github.com/chuot/rdio-scanner/releases and select the appropriate package for your system:

# Example for Linux amd64
wget https://github.com/chuot/rdio-scanner/releases/download/v6.6.3/rdio-scanner-linux-amd64-v6.6.3.zip

# Example for Windows (PowerShell)
Invoke-WebRequest -Uri "https://github.com/chuot/rdio-scanner/releases/download/v6.6.3/rdio-scanner-windows-amd64-v6.6.3.zip" -OutFile "rdio-scanner.zip"

# Example for macOS
curl -LO https://github.com/chuot/rdio-scanner/releases/download/v6.6.3/rdio-scanner-macos-amd64-v6.6.3.zip

Step 2: Extract and Prepare Unzip the archive to a dedicated directory. The package includes the main executable, configuration templates, and comprehensive PDF documentation.

# Linux/macOS
unzip rdio-scanner-linux-amd64-v6.6.3.zip -d /opt/rdio-scanner
cd /opt/rdio-scanner
chmod +x rdio-scanner

# Windows
Expand-Archive -Path rdio-scanner.zip -DestinationPath C:\RdioScanner

Step 3: Initial Configuration Run the executable once to generate default configuration files:

./rdio-scanner

The system creates config.json and initializes data directories. Press Ctrl+C to stop the initial run.

Step 4: Configure Recorder Sources Edit config.json to add your recorder sources. For Dirwatch mode:

{
  "sources": [
    {
      "type": "dirwatch",
      "name": "TrunkRecorder_Output",
      "path": "/var/recordings/trunk-recorder",
      "extension": ".wav",
      "deleteAfter": false
    }
  ]
}

Step 5: Launch and Access Start the service and access the web dashboard at http://localhost:3000:

# Run in foreground
./rdio-scanner

# Run as system service (Linux)
sudo cp rdio-scanner.service /etc/systemd/system/
sudo systemctl enable rdio-scanner
sudo systemctl start rdio-scanner

Method 2: Docker Deployment

Step 1: Create Docker Compose File

# docker-compose.yml
version: '3.8'
services:
  rdio-scanner:
    image: chuot/rdio-scanner:latest
    container_name: rdio-scanner
    ports:
      - "3000:3000"
    volumes:
      - ./config:/app/config
      - ./recordings:/app/recordings
      - ./data:/app/data
    environment:
      - TZ=America/New_York
    restart: unless-stopped

Step 2: Launch Container

# Create directories
mkdir -p config recordings data

# Start service
docker-compose up -d

# View logs
docker logs -f rdio-scanner

Step 3: Configure Volume Mounts Map your recorder output directories into the container:

volumes:
  - /path/to/trunk-recorder/output:/app/recordings/trunk:ro
  - /path/to/rtlsdr-airband:/app/recordings/airband:ro

REAL Code Examples from the Repository

Example 1: Multi-Source Configuration Pattern

This configuration demonstrates how to integrate multiple SDR recorders simultaneously, leveraging both API and Dirwatch methods:

{
  "server": {
    "host": "0.0.0.0",
    "port": 3000,
    "dataDir": "./data",
    "tempDir": "./tmp"
  },
  "sources": [
    {
      "type": "api",
      "name": "voxcall_feed",
      "token": "secure_api_token_here",
      "allowedIPs": ["192.168.1.100", "10.0.0.0/8"]
    },
    {
      "type": "dirwatch",
      "name": "trunk_recorder_p25",
      "path": "/var/recordings/p25",
      "extension": ".wav",
      "pattern": "(*)_(*)_(*).wav",
      "metadata": {
        "system": 1,
        "talkgroup": 2,
        "timestamp": 3
      },
      "deleteAfter": false,
      "scanInterval": 5
    },
    {
      "type": "dirwatch",
      "name": "rtlsdr_airband",
      "path": "/var/recordings/airband",
      "extension": "*.mp3",
      "pattern": "airband_(*)_(*).mp3",
      "metadata": {
        "frequency": 1,
        "timestamp": 2
      }
    }
  ],
  "database": {
    "type": "sqlite",
    "path": "./data/rdio-scanner.db"
  }
}

Explanation: This JSON configuration defines three distinct audio sources. The API source accepts pushed data from voxcall with IP whitelisting for security. The first Dirwatch entry monitors Trunk Recorder's P25 phase 2 outputs, using pattern matching to extract system, talkgroup, and timestamp from filenames. The second Dirwatch handles RTLSDR-Airband's MP3 files. The scanInterval of 5 seconds ensures near-real-time ingestion without excessive disk I/O.

Example 2: Docker Run Command with Advanced Parameters

For users preferring direct Docker commands over Compose, this example includes volume mappings, resource limits, and environment variables:

docker run -d \
  --name rdio-scanner-prod \
  -p 3000:3000 \
  -v /opt/rdio/config:/app/config \
  -v /var/recordings/trunk:/app/recordings/trunk:ro \
  -v /var/recordings/sdrtrunk:/app/recordings/sdrtrunk:ro \
  -v /opt/rdio/data:/app/data \
  -e TZ=America/Los_Angeles \
  -e LOG_LEVEL=info \
  -e MAX_AUDIO_AGE=720h \
  --memory="2g" \
  --cpus="1.5" \
  --restart unless-stopped \
  chuot/rdio-scanner:latest

Explanation: This command deploys Rdio Scanner as a detached container with production-grade settings. The :ro suffix mounts recorder directories as read-only for security. MAX_AUDIO_AGE=720h automatically purges audio older than 30 days. Resource limits prevent the container from consuming excessive host resources. The TZ environment variable ensures timestamps align with your local timezone.

Example 3: Systemd Service File for Linux Servers

For persistent operation on Linux systems, this systemd unit file enables automatic startup and crash recovery:

[Unit]
Description=Rdio Scanner SDR Audio Distribution
After=network.target
Wants=network.target

[Service]
Type=simple
User=rdio
Group=rdio
WorkingDirectory=/opt/rdio-scanner
ExecStart=/opt/rdio-scanner/rdio-scanner
Restart=on-failure
RestartSec=30
StandardOutput=journal
StandardError=journal
SyslogIdentifier=rdio-scanner
# Security hardening
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/opt/rdio-scanner/data /var/recordings

[Install]
WantedBy=multi-user.target

Explanation: This service definition runs Rdio Scanner as a non-privileged user for security. Restart=on-failure ensures automatic recovery from crashes. The hardening directives (NoNewPrivileges, ProtectSystem) sandbox the process, limiting potential attack vectors. ReadWritePaths explicitly grants access only to necessary directories, following principle of least privilege.

Example 4: Nginx Reverse Proxy Configuration

For public-facing deployments, this Nginx configuration adds SSL termination and rate limiting:

# /etc/nginx/sites-available/rdio-scanner
upstream rdio_backend {
    server 127.0.0.1:3000;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name scanner.yourdomain.com;
    
    ssl_certificate /etc/letsencrypt/live/scanner.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/scanner.yourdomain.com/privkey.pem;
    
    # Rate limiting
    limit_req_zone $binary_remote_addr zone=rdio_limit:10m rate=10r/s;
    limit_req zone=rdio_limit burst=20 nodelay;
    
    client_max_body_size 50M;
    
    location / {
        proxy_pass http://rdio_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 86400;
    }
    
    location /api/ {
        # Stricter rate limiting for API endpoints
        limit_req zone=rdio_limit burst=5 nodelay;
        proxy_pass http://rdio_backend/api/;
    }
}

Explanation: This configuration exposes Rdio Scanner securely to the internet. SSL certificates from Let's Encrypt encrypt traffic. The rate limiting prevents abuse while allowing legitimate usage bursts. WebSocket support (Upgrade headers) enables real-time audio streaming. The separate location /api/ block applies stricter limits to programmatic endpoints, protecting backend resources.

Advanced Usage & Best Practices

Optimize Audio Storage: Implement tiered storage strategies. Keep recent audio (24-48 hours) on fast SSD storage for quick access, then automatically archive older files to slower HDDs or cloud object storage. Use the MAX_AUDIO_AGE environment variable with a custom script to move files rather than delete them.

Leverage Metadata Enrichment: Enhance searchability by configuring your recorders to embed rich metadata. Trunk Recorder users should enable talkgroupFormat and callLog options. Rdio Scanner parses this data to enable filtering by agency, unit ID, or geographic zone—transforming raw audio into an intelligence database.

Implement High-Availability: For mission-critical deployments, run multiple Rdio Scanner instances behind a load balancer with shared storage (NFS/S3). Use PostgreSQL instead of SQLite by configuring the database section for concurrent access. This architecture eliminates single points of failure.

Secure Your Deployment: Never expose the admin interface directly to the internet. Always use a reverse proxy with authentication. Create separate API tokens for each recorder source, and rotate them quarterly. Regularly audit access logs for unusual patterns.

Monitor Performance: Enable detailed logging and integrate with Prometheus via the /metrics endpoint (if available). Track key metrics: audio ingestion rate, API response times, active user count, and storage growth. Set alerts when ingestion lags behind recorder output, indicating I/O bottlenecks.

Mobile Optimization: The native apps use the restricted WebSocket API for battery-efficient streaming. Encourage mobile users to download the official apps rather than using mobile browsers. Configure mobileCacheSize in settings to limit local storage usage on devices.

Comparison with Alternatives

Why Choose Rdio Scanner? Unlike OpenMHz's cloud dependency, Rdio Scanner runs entirely on your infrastructure—critical for sensitive communications. It surpasses Trunking Recorder's iOS exclusivity with cross-platform mobile support. While SDRTrunk offers excellent metadata, its web interface targets advanced users; Rdio Scanner's scanner-inspired UI democratizes access for non-technical team members. The universal Dirwatch capability means you're not locked into specific recorder software, future-proofing your investment.

Frequently Asked Questions

Q: Can I use Rdio Scanner with analog radio recordings? A: Absolutely! While optimized for digital trunked systems, any recorder producing per-transmission audio files works. Configure Dirwatch with appropriate file patterns and metadata extraction rules. Analog recordings from voxcall or DSDPlus integrate seamlessly.

Q: What are the WebSocket API restrictions? A: The WebSocket API is exclusively licensed to Saubeo Solutions for official mobile apps. Third-party developers cannot use it for custom clients. However, the REST API remains fully open for automation, data export, and integration with other tools. This policy ensures mobile experience quality and funds continued development.

Q: How many concurrent users can Rdio Scanner support? A: On modest hardware (4 CPU cores, 8GB RAM), Rdio Scanner handles 50+ concurrent web users and 100+ API connections. Performance depends on audio ingestion rate and storage I/O. For larger deployments, use PostgreSQL and separate web/application servers. The Docker image scales horizontally behind a load balancer.

Q: Does Rdio Scanner support real-time audio processing like DMR decoding? A: No—Rdio Scanner focuses on ingestion and distribution, not decoding. It processes audio files after your SDR recorder creates them. For decoding, use Trunk Recorder with DMR/MotoTRBO plugins or DSDPlus, then feed the decoded audio to Rdio Scanner.

Q: Can I customize the web interface's appearance? A: Limited theming is available through the admin panel (dark/light modes, accent colors). The interface is intentionally scanner-like and not fully themeable. However, you can modify the open-source frontend code and rebuild, though this voids official support. Most users find the default design optimal for extended monitoring sessions.

Q: What happens if my recorder produces thousands of files per hour? A: Rdio Scanner's Dirwatch uses efficient filesystem event monitoring (inotify on Linux) rather than polling, minimizing CPU impact. For extreme volumes (>10k files/hour), increase scanInterval and deploy multiple instances with partitioned source directories. The SQLite database may bottleneck; switch to PostgreSQL for high-throughput scenarios.

Q: Is there a way to automatically export audio to cloud storage? A: Yes! Configure a cron job or systemd timer to run a script that uploads files from the data directory to S3, Google Cloud Storage, or Azure Blob. Use the API to identify files by date range. For real-time sync, implement a webhook listener that triggers on new transmission events.

Conclusion: Your SDR Workflow Deserves Rdio Scanner

Rdio Scanner transcends typical open-source projects by solving a niche problem with enterprise-grade execution. Its thoughtful blend of nostalgic scanner interface and modern architecture creates an experience that feels both familiar and revolutionary. Whether you're a hobbyist monitoring local repeaters or a professional managing multi-agency communications, this tool eliminates friction and amplifies capability.

The active development, responsive community, and transparent roadmap signal long-term viability. While the WebSocket API restrictions may frustrate some developers, they represent a sustainable funding model that keeps the core project free and open. The mobile apps' seamless integration justifies this trade-off for most users.

Take action now: Download the latest release from https://github.com/chuot/rdio-scanner, join the Discord community for real-time support, and star the repository to support continued innovation. Your SDR recordings are valuable—give them the distribution platform they deserve. Happy Rdio scanning!

Ready to transform your radio monitoring? Visit the official repository and start scanning smarter today.