LibreSpeed

Open-source network testing, honestly reviewed. No tracking pixels, no Ookla servers, just your own infrastructure.

TL;DR

• What it is: Lightweight, self-hosted internet speed test written in JavaScript — no Flash, no Java, no WebSocket tricks, no third-party data collection [README][1].
• Who it’s for: Sysadmins, homelab enthusiasts, ISPs, and hosting companies who want accurate connection benchmarking without shipping test data to Ookla or Netflix [README][5].
• Cost savings: Speedtest.net is free to use, so personal savings aren’t the pitch. The real value is for ISPs and hosting providers who would otherwise pay for Ookla’s commercial “Speedtest Custom” product — LibreSpeed gives you a branded, embeddable speed test at infrastructure cost only [README].
• Key strength: Genuinely minimal. No account required, no tracking by default, no ads, no proprietary backend. Multiple server backends (PHP, Go, Rust, Node.js) and optional database integration for telemetry if you want it [README][1].
• Key weakness: It’s a tool, not a service. Setup requires a web server. The public instance at librespeed.org has had availability complaints. There’s no managed cloud tier — you host it or you don’t [1][README].

---

What is LibreSpeed

LibreSpeed is a browser-based speed test that runs on your own server. You point it at your infrastructure, your visitors run the test, and the results stay with you. The project is built in JavaScript using XMLHttpRequest and Web Workers — no plugins, no runtime dependencies the browser doesn’t already have [README].

The core project (the librespeed/speedtest repo) is the frontend plus a PHP backend. Around it has grown an ecosystem of alternative backends: a Go implementation maintained by Maddie Zhan in speedtest-go, a Rust implementation in speedtest-rust, and a partial Node.js implementation in the node branch. There’s also an Android client on F-Droid, a CLI client, and a .NET library [README].

What it measures: download speed, upload speed, ping, jitter, and optionally IP address, ISP name, and estimated distance from the test server. Telemetry — storing results in a database — is optional and off by default. If you turn it on, you can offer result sharing (a shareable image or link) [README][1].

The project was created by Federico Dossena (Italy) and released under LGPL-3.0. As of April 2026 it sits at 14,545 GitHub stars with 2,449 forks — ranked #14 in the networking category on Grepository [1][4]. It’s been around since 2016, which in the open-source tools space is a good sign: the boring infrastructure problems (browser compatibility, backend correctness) are largely solved.

---

Why people choose it over Speedtest.net and Fast.com

The comparison set here is different from most self-hosted tools. The “incumbent” isn’t expensive SaaS — it’s Speedtest by Ookla (745 likes on AlternativeTo, #1 in the category) and Fast.com (Netflix-backed, #3) [2]. Both are free to use. So why self-host?

Privacy and data sovereignty. Every test you run on Speedtest.net sends your IP, ISP, location, and connection metrics to Ookla. Fast.com does the same to Netflix. For an individual checking their home connection once a month, this is low stakes. For a company benchmarking employee connections, a hosting provider diagnosing customer complaints, or anyone who’d rather not feed commercial analytics companies with network data — the self-hosted option is the obvious call [1][5].

AlternativeTo reviewers consistently cite this: “It’s open source, without any bloatware or ad flood” [1]. The project’s own tagline — “No Flash, No Java, No Websocket, No Bullshit” — is a direct shot at Ookla’s heavier implementation [README].

Accuracy for your own infrastructure. When you test against librespeed.org or speedtest.net, you’re measuring the path to their servers. When you deploy LibreSpeed on your own server, you’re measuring the path to your own infrastructure. For hosting companies, ISPs, or anyone who needs to tell a customer “your connection to our servers is X Mbps,” running LibreSpeed on your own hardware gives you a test that’s actually meaningful [README][4].

Embedding and branding. The LGPL-3.0 license lets you embed LibreSpeed in any project, including commercial ones, without open-sourcing your entire product. ISPs embed it in their customer portals. Hosting companies put it on their status pages. This is the commercial use case where LibreSpeed actually replaces a paid product — Ookla sells “Speedtest Custom” (white-label hosted speed test) to exactly this audience [README][1].

The public instance caveat. One AlternativeTo commenter noted “No servers available” when trying librespeed.org directly [1]. The public instance is a demonstration, not a service. If you’re using LibreSpeed as an end user hitting someone else’s deployment, you’re dependent on their uptime. The tool’s value is in hosting your own.

---

Features

Core measurements:

• Download speed, upload speed, ping, jitter [README]
• IP address, ISP name, distance from server (optional, via IP lookup database) [README]
• Multiple Points of Test — run a single frontend against multiple backend servers, auto-selecting nearest [README]

Backend options:

• PHP (primary, requires Apache/nginx + PHP 5.4+) [README]
• Go (speedtest-go repo) — better performance for high-traffic deployments [README]
• Rust (speedtest-rust repo) — most efficient option for resource-constrained servers [README]
• Node.js (partial, not recommended for production) [README]

Database support (all optional):

• MySQL/MariaDB, PostgreSQL, SQLite, Microsoft SQL Server — for storing test results and enabling telemetry [README][merged profile]

Client ecosystem:

• Browser (all modern browsers including IE11, Edge, Chrome, Firefox, Safari) [README]
• Android app (F-Droid) [README][1]
• CLI client (speedtest-cli repo) [README]
• .NET client library (NuGet) [README]
• Linux GUI (GTK4/libadwaita, third-party, packaged as “Speedtest” by Ketok4321) [5]

Optional features:

• Telemetry and result storage [README]
• Shareable result links/images [README]
• Docker deployment [README]
• Configurable test parameters [4]

The Grepository profile notes LibreSpeed also supports distributed edge testing (measuring against multiple geographically distributed servers), loaded latency measurement (capturing latency during active transfers, not just idle), and configurable test duration and parallel streams [4]. The Docker image is rebuilt weekly to include updated ipinfo database entries for ISP detection and current PHP security patches — a small but useful maintenance signal that the project hasn’t gone dormant [README].

---

Pricing: SaaS vs self-hosted math

LibreSpeed has no commercial tier. The math here is different depending on who you are.

For individual users: Speedtest.net and Fast.com are free. You’re not saving money by self-hosting LibreSpeed — you’re paying ~$5–10/month for a VPS to get privacy and control you didn’t have before. Whether that’s worth it is a personal call.

For ISPs and hosting companies: Ookla’s commercial “Speedtest Custom” product (white-label, embeddable speed test for your customer portal) has commercial pricing — Ookla doesn’t publish it publicly, so specific numbers aren’t available. LibreSpeed on a VPS or your own hardware is infrastructure cost only. For a hosting company that would otherwise write a check to Ookla for branding and embedding rights, LibreSpeed on a $10–20/month server is the obvious alternative [README][1].

Self-hosted infrastructure costs:

• Basic VPS (sufficient for low-to-medium traffic): $5–10/month (Hetzner, Contabo, DigitalOcean)
• The VPS needs a fast internet uplink — this is the actual cost driver for a production deployment. A 1Gbps-capable server costs more than a standard VPS. For most homelabs and small ISPs, a standard VPS is fine.
• PHP/Go/Rust backend: $0 [README]
• Domain + SSL: ~$10–15/year for a domain; SSL via Let’s Encrypt is free

For enterprise/ISP deployments at real scale: a dedicated server with a 10Gbps uplink will run $80–200/month depending on provider. This is the tier where the comparison to Ookla’s custom product becomes a serious financial decision, and LibreSpeed wins on cost every time [README].

---

Deployment reality check

LibreSpeed’s README install path is explicit: download source, copy files to your web root, optionally set up a database. That’s it for the simplest case [README].

What you actually need:

• A Linux server (VPS or bare metal) with Apache, nginx, or IIS
• PHP 5.4 or newer for the default backend (or Go/Rust if you prefer those)
• MariaDB/MySQL, PostgreSQL, or SQLite if you want telemetry and result storage (optional)
• A fast internet connection — the server’s uplink is the ceiling on test results
• Domain name and HTTPS (Certbot/Let’s Encrypt works fine)

Docker path: A Docker image is available and is the cleaner route for most deployments. The image is rebuilt weekly [README].

What can go sideways:

The multiple backend situation creates some decision overhead. The PHP backend is the reference implementation and best documented. The Go and Rust backends are maintained by third parties — they’re solid but you’re relying on their maintainers for updates [README]. The Node.js backend is explicitly “not recommended to use at the moment” [README]. Pick PHP unless you have a specific reason to go otherwise.

For Multiple Points of Test (running a frontend that auto-selects the nearest backend from a pool), setup is significantly more involved. You need multiple servers deployed, configured in a JSON list, and coordinated. The feature works but the documentation is thinner than for single-server deployments [README].

The public server availability issue noted by AlternativeTo users [1] is a reminder that if you’re deploying this for real traffic (customer portal, production ISP tool), you need to monitor the deployment properly. LibreSpeed doesn’t include any health-check or monitoring infrastructure — bring your own.

Realistic time estimate for a technical user: 20–45 minutes to a working PHP deployment on an existing LAMP/LEMP server. On a fresh VPS: 1–2 hours including web server setup, SSL, and optional database. For Docker: 15–30 minutes if you’ve touched Docker before.

---

Pros and cons

Pros

• LGPL-3.0 license — embeddable in commercial products without GPL contamination. ISPs and hosting companies can drop it in their customer portals without a lawyer conversation [README][1].
• Genuinely lightweight — no Flash, Java, or WebSocket. Runs in IE11. Loads fast. Doesn’t phone home by default [README].
• Multiple backends — PHP, Go, Rust, Node.js. Match the backend to your infrastructure preferences; don’t force PHP if you’re a Go shop [README].
• Optional telemetry — you control what data gets stored. Default is nothing. Turn it on when you want result history [README].
• Multiple Points of Test — geographically distributed testing from a single frontend [README].
• Multiple database options — MySQL, PostgreSQL, SQLite, MSSQL. Works with whatever you already run [README][merged profile].
• Active maintenance — Docker image rebuilt weekly, 14K+ stars, weekly star activity (+85 in last 7 days per Grepository) [4][README].
• Broad client support — browser, Android (F-Droid), CLI, .NET, Linux GUI [README][5][1].
• No account required — for end users taking the test, zero friction [1].

Cons

• Not a service — librespeed.org is a demo. If you want a speed test, you host one. There is no managed cloud tier [1][README].
• Public instance reliability — the demo at librespeed.org has had “no servers available” reports, which hurts first impressions for people evaluating before committing to self-hosting [1].
• Multiple PoT setup is non-trivial — the documentation for multi-server deployments is sparse compared to single-server [README].
• Node.js backend is not production-ready — explicitly flagged in the README as not recommended [README]. Don’t use it.
• Third-party backends (Go, Rust) are maintained outside the core project — quality is good, but you’re depending on individual maintainers, not the original author [README].
• No built-in monitoring or alerting — if your LibreSpeed server goes down, users get a broken test. No health checks included.
• Server uplink is the real cost driver at scale — a 10Gbps-capable server for genuine ISP use is not a $5/month VPS. Budget accordingly.
• Thinner documentation than polished SaaS tools — the install path is simple, but edge cases (reverse proxy config, specific database tuning, PoT coordination) require digging through the repo [README].

---

Who should use this / who shouldn’t

Use LibreSpeed if:

• You run an ISP, hosting company, or CDN and want a branded speed test for your customer portal without paying Ookla for the commercial product.
• You manage a homelab or self-hosted infrastructure stack and want speed testing that measures your own servers rather than Ookla’s.
• You’re privacy-conscious and don’t want test results stored on Ookla’s or Netflix’s servers.
• You need to embed a speed test in a commercial product — LGPL-3.0 makes this clean.
• You want the test to target specific server geography, not random public nodes.

Skip it (use Speedtest.net) if:

• You’re an individual checking your home connection occasionally and don’t care about privacy trade-offs. Ookla has a global server network that gives you a more representative benchmark of general internet performance.
• You want to compare your connection against aggregate data (Ookla publishes ISP performance reports). LibreSpeed gives you no comparative data.

Skip it (use Fast.com) if:

• You primarily want to know if Netflix is going to buffer. Fast.com measures the Netflix CDN path specifically, which is more relevant than a general speed test for that use case.

Skip it (use iPerf3) if:

• You’re benchmarking internal LAN or datacenter connections. LibreSpeed is designed for internet-facing tests. iPerf3 is the right tool for private network benchmarking.

---

Alternatives worth considering

• Speedtest by Ookla — the incumbent. Largest server network, most recognized brand, proprietary, ships data to Ookla. Free for personal use; commercial embedding requires licensing [2].
• Fast.com — Netflix-backed, single-purpose download test, no self-hosting option, accurate for Netflix CDN paths specifically [2].
• nPerf — European alternative to Ookla, proprietary, no self-hosting.
• iPerf3 — the right tool if you want LAN/internal network benchmarking. Not browser-based, no pretty UI, but far more accurate for private network performance testing.
• Openspeedtest — another self-hosted HTML5 speed test. Fewer stars, similar use case. LibreSpeed has a larger ecosystem and more backend options.
• Cloudflare Speed Test (speed.cloudflare.com) — technically impressive (measures loaded latency, packet loss, uses Cloudflare’s edge), but proprietary and not self-hostable [4].

For a non-technical user who just wants to check their connection: Speedtest.net. For anyone running infrastructure who wants to own the test: LibreSpeed.

---

Bottom line

LibreSpeed is a well-executed, boring infrastructure tool. It does one thing — run a speed test against your own server — and it does it cleanly without third-party dependencies or data collection. The LGPL license means ISPs and hosting companies can embed it without legal overhead. The multiple backend options (PHP, Go, Rust) mean you can match it to your stack. The 10-year track record and weekly Docker image updates mean it’s not going to disappear.

The pitch isn’t cost savings for individuals — Speedtest.net is free. The pitch is control: knowing that the test traffic hits your servers, results stay in your database, and no one at Ookla is building a dataset out of your customers’ connection measurements. For anyone running self-hosted infrastructure who hasn’t set this up yet, it’s a two-hour afternoon project that closes a genuine data sovereignty gap.

If you want that afternoon to be thirty minutes instead of two hours, that’s exactly the kind of deployment upready.dev handles for clients.

---

Sources

1. AlternativeTo — LibreSpeed: Self-hosted Speedtest for HTML5 (9 reviews, 4.6/5, 73 likes). https://alternativeto.net/software/html5-speedtest/about/
2. AlternativeTo — Network Tools category listing (includes LibreSpeed, Speedtest by Ookla, Fast.com comparative context). https://alternativeto.net/category/networking-and-admin/network-utility/
3. AlternativeTo — Apps with ‘Html5’ feature (LibreSpeed in context of HTML5 application category). https://alternativeto.net/browse/all/?tag=html5
4. Grepository — LibreSpeed GitHub Stats & Trends (14.6K stars, 2.5K forks, #14 in networking, +85 stars/7d). https://www.greptile.com/grepository/speedtest
5. Softpedia Linux — Speedtest (LibreSpeed GUI client) (review of GTK4/libadwaita frontend by Vladimir Ciobica, 4.0/5). https://linux.softpedia.com/get/Utilities/Speedtest-Ketok4321-104620.shtml

Primary sources:

• GitHub repository and README: https://github.com/librespeed/speedtest (14,438+ stars, LGPL-3.0)
• Official website and public demo: https://librespeed.org
• Go backend repository: https://github.com/librespeed/speedtest-go
• Rust backend repository: https://github.com/librespeed/speedtest-rust
• Android client: https://github.com/librespeed/speedtest-android