LibreSpeed vs Speedtest Tracker: Which to Self-Host?

Quick Verdict

These tools measure fundamentally different things. LibreSpeed tests the speed between your device and your own server — useful for diagnosing LAN performance, Wi-Fi dead zones, and internal network bottlenecks. Speedtest Tracker tests the speed between your server and Ookla’s infrastructure, then logs it over time — useful for holding your ISP accountable and spotting degradation patterns. Most self-hosters benefit from running both.

Overview

LibreSpeed is a lightweight HTML5 speed test that runs entirely on your hardware. You open it in a browser, it measures upload, download, ping, and jitter against your server. No third-party services involved, no data leaves your network. It is a fork-and-go tool: deploy the container, hit the URL, get results.

Speedtest Tracker is a monitoring dashboard built on top of Ookla’s official Speedtest CLI. It runs scheduled tests against Ookla’s global server network, stores results in a database, and presents them as historical graphs. Think of it as automated speedtest --simple with a web UI and notifications.

The key distinction: LibreSpeed answers “how fast is my internal network?” Speedtest Tracker answers “how fast is my ISP delivering right now, and how has that changed over the past month?”

Feature Comparison

Feature	LibreSpeed	Speedtest Tracker
What it measures	Client ↔ your server	Your server ↔ Ookla servers (ISP speed)
Scheduled tests	No (manual/on-demand)	Yes (cron-based, configurable intervals)
Historical data	Optional (requires backend)	Yes (built-in database + graphs)
Database required	No (runs without one)	Yes (SQLite, PostgreSQL, or MySQL)
External dependencies	None	Ookla Speedtest CLI
Multiple test points	Yes (configure multiple servers)	Yes (select from Ookla’s server list)
Notifications	No	Yes (Slack, Discord, Telegram, email, etc.)
API	Basic telemetry endpoint	Full REST API
Authentication	Optional (basic auth)	Built-in user management
Resource usage	~30 MB RAM	~80-150 MB RAM (with database)
License	LGPL-3.0	MIT
Mobile-friendly UI	Yes	Yes

What Each Tool Actually Measures

This is the most important section. Get this wrong, and you will deploy the wrong tool.

LibreSpeed runs the test between the browser on your device and the LibreSpeed container on your server. If you run LibreSpeed on a Raspberry Pi in your closet and test from your laptop on Wi-Fi, you are measuring: your laptop’s Wi-Fi speed → your router → your Pi’s ethernet connection. Your ISP is never involved. This makes LibreSpeed ideal for:

• Diagnosing slow Wi-Fi in specific rooms
• Verifying gigabit LAN is actually delivering gigabit
• Testing VPN tunnel throughput
• Benchmarking different network configurations

Speedtest Tracker runs the test between your server and Ookla’s nearest speed test server on the public internet. Your ISP is the entire point. This makes Speedtest Tracker ideal for:

• Verifying you get the speeds you pay for
• Detecting ISP throttling at specific times
• Building evidence for ISP support tickets
• Monitoring connection stability over weeks or months

Docker Compose: LibreSpeed

Create a docker-compose.yml:

services:
  librespeed:
    image: lscr.io/linuxserver/librespeed:5.5.1
    container_name: librespeed
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      # Set to true to enable result logging to a database
      - DB_TYPE=none
      # Custom test title shown in the web UI
      - CUSTOM_RESULTS=false
    ports:
      - "8880:80"
    restart: unless-stopped

Start it:

docker compose up -d

Access the speed test at http://your-server-ip:8880. No setup wizard, no accounts — it works immediately.

If you want to persist test results, change DB_TYPE to sqlite, mysql, or postgresql and add the corresponding database configuration. For most LAN testing use cases, storing results is unnecessary.

Docker Compose: Speedtest Tracker

Create a docker-compose.yml:

services:
  speedtest-tracker:
    image: lscr.io/linuxserver/speedtest-tracker:1.1.2
    container_name: speedtest-tracker
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      # Database connection — using SQLite for simplicity
      - DB_CONNECTION=sqlite
      # App URL used for generating links in notifications
      - APP_URL=http://localhost:8881
      # How often to run a speed test (cron expression — every hour)
      - SPEEDTEST_SCHEDULE=0 * * * *
      # Set to true after initial setup to skip the setup wizard
      - SETUP_COMPLETED=false
    volumes:
      - speedtest-data:/config
    ports:
      - "8881:80"
    restart: unless-stopped

volumes:
  speedtest-data:

Start it:

docker compose up -d

Access the dashboard at http://your-server-ip:8881. On first launch, you will create an admin account through the setup wizard. The default schedule runs a speed test every hour. Adjust SPEEDTEST_SCHEDULE using standard cron syntax — */30 * * * * for every 30 minutes, 0 */6 * * * for every 6 hours.

For production use with heavy history, swap SQLite for PostgreSQL:

services:
  speedtest-tracker:
    image: lscr.io/linuxserver/speedtest-tracker:1.1.2
    container_name: speedtest-tracker
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - DB_CONNECTION=pgsql
      - DB_HOST=speedtest-db
      - DB_PORT=5432
      - DB_DATABASE=speedtest
      - DB_USERNAME=speedtest
      # Change this to a strong password
      - DB_PASSWORD=changeme-strong-password
      - APP_URL=http://localhost:8881
      - SPEEDTEST_SCHEDULE=0 * * * *
    volumes:
      - speedtest-data:/config
    ports:
      - "8881:80"
    depends_on:
      speedtest-db:
        condition: service_healthy
    restart: unless-stopped

  speedtest-db:
    image: postgres:16.2-alpine
    container_name: speedtest-db
    environment:
      - POSTGRES_DB=speedtest
      - POSTGRES_USER=speedtest
      # Must match DB_PASSWORD above
      - POSTGRES_PASSWORD=changeme-strong-password
    volumes:
      - speedtest-db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U speedtest"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

volumes:
  speedtest-data:
  speedtest-db-data:

Installation Complexity

LibreSpeed wins here. One container, no database, no setup wizard. Deploy it and you are done in under a minute.

Speedtest Tracker requires a database (SQLite at minimum), an initial account setup, and cron schedule configuration. With PostgreSQL, you are managing two containers. Still straightforward by self-hosting standards, but meaningfully more involved than LibreSpeed.

Performance and Resource Usage

LibreSpeed idles at roughly 30 MB RAM. During a test, CPU spikes briefly as the server handles the data transfer. Disk usage is negligible unless you enable result logging.

Speedtest Tracker with SQLite uses around 80-100 MB RAM. With PostgreSQL, the combined stack sits at 150-200 MB. Disk usage grows over time as test results accumulate — expect roughly 1 MB per 1,000 tests. CPU usage spikes during scheduled tests but is otherwise minimal.

Neither tool is resource-intensive. Both run comfortably on a Raspberry Pi 4 or any entry-level VPS.

Community and Support

Aspect	LibreSpeed	Speedtest Tracker
GitHub stars	12,000+	4,000+
Development activity	Stable, infrequent updates	Active, regular releases
Documentation	Basic but sufficient	Comprehensive docs site
Community	GitHub issues, Reddit	GitHub issues, Discord, Reddit

LibreSpeed is a mature project that does one thing well. Updates are infrequent because there is not much to change. Speedtest Tracker is more actively developed with a larger feature surface — notifications, API integrations, and UI improvements ship regularly.

Use Cases

Deploy LibreSpeed If…

• You want to test speeds between devices on your local network
• You need to diagnose Wi-Fi performance across your home
• You want a speed test that involves zero external services
• You are benchmarking different network hardware or configurations
• You want a privacy-first speed test with no data leaving your network
• You need multiple test endpoints across different locations you control

Deploy Speedtest Tracker If…

• You want to monitor your ISP’s actual delivered speeds over time
• You need historical graphs to spot performance degradation
• You want alerts when speeds drop below a threshold
• You are building evidence for an ISP dispute
• You want automated testing on a schedule without manual intervention
• You need an API to integrate speed data into your monitoring stack

Deploy Both If…

• You want complete visibility into both internal network health and ISP performance
• You run a homelab and want to know if slowness is your LAN or your ISP

Final Verdict

LibreSpeed and Speedtest Tracker are not competitors — they are complements. Comparing them is like comparing a thermometer to a weather station. One gives you a reading right now, on your terms. The other tracks conditions over time against an external baseline.

If you only deploy one: Choose based on your actual problem. Slow file transfers between machines on your network? LibreSpeed. Suspecting your ISP is not delivering what you pay for? Speedtest Tracker.

If you have the resources: Run both. LibreSpeed costs almost nothing in terms of resources, and Speedtest Tracker with SQLite is barely heavier. Together they give you full visibility into your network from the inside out.

Related

• How to Self-Host LibreSpeed
• How to Self-Host Speedtest Tracker
• Best Self-Hosted Speed Test Tools
• Docker Compose Basics
• Docker Networking Explained
• Getting Started with Self-Hosting