Sseekdeploy

Locust

Load testing written as plain Python classes, with a live web UI and a worker model for scaling out.

Open source · MITFree#load-testing#performance#python

What is Locust?

Locust is an open-source load-testing tool written in Python. You describe a simulated user as a Python class in a locustfile: its tasks are methods that make requests, and a wait time sets the pause between them. Locust runs thousands of these users as gevent greenlets, shows live statistics in a web UI or runs headless for CI, and writes CSV and HTML reports. One Python process uses about one CPU core, so bigger tests run as a master plus workers, on one machine with --processes or across many. HttpUser is built on python-requests; FastHttpUser on the faster geventhttpclient.

Locust is MIT-licensed and has no paid edition. Jonatan Heyman created it, Lars Holmberg maintains it, and Microsoft sponsors its maintenance. The maintainers' hosted service, Locust Cloud, began shutting down at the end of 2025; locust.cloud now points to Microsoft's Azure App Testing, which runs Locust scripts.

The current release is 2.47.0 (21 October 2026), which made the web UI's /stop and /stats/reset endpoints POST-only. Python 3.11 or newer is required since 2.46.1 (July 2026). It is the main Python alternative to k6.

Our review

4.0

The load-testing tool to pick if your team writes Python. Users are plain classes, so real per-user logic and pip packages just work, and the live web UI is the friendliest in the category. The cost is efficiency and plumbing: from the same two vCPUs it generated about 64% of k6's request rate with FastHttpUser and 15% with the default HttpUser, and you wire up workers and CI pass/fail yourself.

Pros

  • + Load scripts are ordinary Python, with imports, pip packages and per-user state
  • + Live web UI to watch and change a run, plus a headless mode for CI
  • + MIT-licensed, actively maintained (77 merged PRs in the last 90 days), with no paid tier to upsell

Cons

  • − Less load per core than k6, and much less with the default HttpUser; you must run one worker per core
  • − No built-in thresholds or arrival-rate model, and the maintainers' hosted service has shut down

Reviewed by SeekDeploy Editorial · updated 2026-11-15. Reviews are independent — we don’t accept payment for coverage or ratings.

Should you use Locust?

A good fit if you're…

  • Python teams who want load tests in the same language as their backend, using ordinary imports and pip packages
  • Testing flows with real logic per user (login, state, branching) that's awkward in a declarative tool
  • Exploratory load testing where someone watches the live web UI and adjusts the user count mid-run
  • Targets beyond HTTP that Python can reach, such as MQTT or MongoDB, via contributed or custom User classes

Probably not for you if you're…

  • Squeezing the most requests out of one small load generator: k6 pushed ~1.6x Locust's FastHttpUser from the same two vCPUs in our test
  • Teams that want pass/fail thresholds built into the tool for CI; Locust needs a small event hook or plugin for that
  • Windows-only load generators that need multi-core runs: --processes relies on fork()
  • Teams wanting a vendor-run cloud from the same people; Locust Cloud is gone and the hosted path is Azure

Pick something else if…

  • you want a single binary, built-in CI thresholds, arrival-rate scenarios and more load per core, and your team is fine writing JavaScript → k6
  • you're a JVM team and want load tests in Java, Kotlin or Scala → Gatling

Gotchas to know before you commit

  • One Python process uses about one CPU core. Without --processes (or separate workers) a multi-core box runs at a fraction of its capacity; Locust logs a warning when a worker is CPU-bound, so watch for it.
  • HttpUser (python-requests) is the default in most examples and is several times slower than FastHttpUser: 5,297 vs 22,711 requests/s in our two-vCPU test. FastHttpUser's client differs in details such as cookie handling.
  • There's no global target-rate setting. constant_throughput and constant_pacing cap each user's rate ('at most'), so when responses slow down, the request rate falls; size the user count for the rate you need.
  • 2.47.0 (October 2026) made the web UI's /stop and /stats/reset endpoints POST-only, and 2.46.1 dropped Python 3.10. Scripts that drive the web API with GET, or CI images on Python 3.10, break on upgrade.
  • Locust Cloud, the maintainers' hosted service, began shutting down at the end of 2025 (2.43.0 changelog). Old docs and blog posts still point to it; the hosted option now is Azure App Testing.

Locust pricing

Checked Nov 15, 2026 against the official pricing page

Locust is free (MIT) with no paid edition from its maintainers; their Locust Cloud service began shutting down at the end of 2025. For hosted scale-out, Microsoft's Azure App Testing runs Locust scripts and bills per virtual-user hour (VUH = users x minutes / 60): $0.15 / VUH for the first 10,000 VUH a month, so large or frequent tests get expensive fast.

Locust (open source)
$0
Anyone running load from their own machines or CI
  • Python locustfiles, web UI and headless mode
  • CSV and HTML reports, OpenTelemetry output
  • Distributed master/worker runs on your own hardware
  • Limit: Load is limited to the machines you run it on
  • Limit: One process per CPU core; you manage the workers
Azure App Testing (Microsoft)
$0.15 / VUH (0-10,000 VUH / month), $0.06 / VUH above
Teams on Azure who want managed load engines
  • Runs existing Locust scripts on managed engines
  • Results alongside Azure resource metrics
  • Azure DevOps and GitHub Actions integration
  • Limit: Minimum charge per run since 1 March 2026: 10 VUs per engine, and at least 10 minutes
  • Limit: Third-party service, not run by the Locust maintainers
  • Limit: Prices are East US list rates from Azure's retail price API; the pricing page renders them dynamically

What it costs in practice

Developer running Locust locally or in CI
$0
Open source. In our test two vCPUs generated ~22,700 requests/s with FastHttpUser and ~5,300 with HttpUser against a trivial local target (see Benchmarks).
100 users, 15-minute test, 20 runs a month on Azure
~$75 / month
100 x 15 / 60 = 25 VUH per run x 20 = 500 VUH x $0.15 = $75 at East US list price. Above the per-engine minimum, so no minimum charge applies.
1,000 users, 30-minute test, 8 runs a month on Azure
~$600 / month
1,000 x 30 / 60 = 500 VUH per run x 8 = 4,000 VUH x $0.15 = $600, all in the first tier. Self-hosting the same load on a few cloud VMs is usually far cheaper.

Estimates in USD from list prices. Your bill depends on usage, region, and discounts.

Health & activity

Updated Nov 15, 2026 · last 90 days
Actively developedFrequent commits or releases in the last 90 days.
GitHub stars
28k
3.3k forks
Commits
180
at least 25 committers
Merged pull requests
77
Issues opened / closed
17 / 18
median 0.9 days to close
Last push
Nov 15, 2026
Open issues & PRs
13

From locustio/locust. Counts cover the last 90 days unless noted.

Downloads

Benchmarks

Our runs include the scripts in the repo, so you can reproduce them

Requests per second from two vCPUs: Locust vs k6

We ran this

Mean HTTP requests/s each tool generated from the same 2 vCPUs with 50 users and no think time against a trivial local target; load-generator capacity, not API speed · req/s, higher is better

  • k6 v2.4.035,385 req/s
  • Locust 2.47.0 FastHttpUser, 2 workers22,711 req/s
  • Locust 2.47.0 HttpUser, 2 workers5,297 req/s
How this was measured

5 interleaved rounds of k6, Locust FastHttpUser and Locust HttpUser, 50 users, no think time, 30 s each, against the same trivial local Go server (~2 KB JSON). Load generator pinned to CPUs 2-3, target to CPUs 0-1 with taskset. Locust: 'locust -f locustfile.py <FastUser|SlowUser> --headless --processes 2 -u 50 -r 50 -t 30s' (master + 2 workers); k6: 'k6 run -e VUS=50 -e DURATION=30s script.js'. Mean of Locust's aggregated Requests/s and k6's http_reqs rate. Runs: k6 35,698 / 34,255 / 35,341 / 35,329 / 36,303; FastHttpUser 22,541 / 23,255 / 22,452 / 22,612 / 22,694; HttpUser 5,205 / 5,257 / 5,333 / 5,342 / 5,347; 0 failed. The generators were the bottleneck (CPUs 2-3 ~80% busy under Locust, target CPUs 10-20%). Locust's throughput depends on its worker count and on FastHttpUser vs HttpUser; other settings were not tested. Scripts: benchmarks/locust/

Environment: 4 vCPU Intel Xeon @ 2.30 GHz (x86_64), 15 GB RAM, Ubuntu 24.04.5; target built with Go 1.24.7; every run started at a 1-minute load average of 1.38-1.49 (shared machine; runs only start below 1.5)

Versions: Locust 2.47.0 (Python 3.13.18, gevent 26.9.0, geventhttpclient 2.6.1); k6 v2.4.0 (go1.26.11)

Run Nov 15, 2026

What the community says

Hacker News & GitHub issues · Aug 17, 2026 – Nov 15, 2026

There wasn’t enough discussion in the last 90 days to summarise fairly. Here’s what there was.

Most-reacted new GitHub issues · 17 opened in the window

Alternatives to Locust

Spotted something wrong or out of date? Flag a correction on GitHub. Health and community data refresh on the 1st and 15th of every month.