Most teams find out what their API does under real load during the incident, not before it. The test that would have caught it is easy to write and awkward to own: it needs an environment close enough to production to mean anything, load generators that are not somebody's laptop, and a bill that grows with the traffic you simulate.
Apache JMeter, still the default answer in a lot of enterprise QA teams, has not shipped a release since version 5.6.3 on January 9, 2024, and the Apache download page still listed 5.6.3 as current on September 13, 2026. Grafana k6 shipped v2.2.0 on August 10, 2026, and Grafana Cloud bills it at $0.150 per virtual user hour past a 500-hour monthly free tier.
What Teams Actually Run
Package downloads are the closest thing to an honest adoption signal here, because nobody registers a load test. Locust recorded 11,281,181 PyPI downloads in the 30 days to September 13, 2026. Artillery recorded 200,252 npm downloads in the week of September 5 to 11, 2026, and in that same week autocannon, a benchmarking CLI rather than a scenario runner, recorded 675,107. That gap shows how much of this category is really request-per-second benchmarking rather than modeled user journeys.
GitHub stars, pulled from the GitHub API on September 13, 2026, rank the projects differently: k6 at 31,459, Locust at 28,148, Vegeta at 25,188, Apache JMeter at 9,529, Artillery at 9,074 and Gatling at 6,955. Stars track attention, not installed base: JMeter has the fewest of the JVM options and almost certainly the largest enterprise footprint.
What the Same Test Costs on Each Platform
A load test is a peak, a duration and a repeat schedule. Take a moderate one: 500 virtual users for 30 minutes, twice a week. Grafana Cloud bills k6 in virtual user hours and publishes the formula in its pricing FAQ as (maximum VUs x test duration in minutes) / 60, so that run is 250 VUh and the month is 2,000 VUh. This script applies each vendor's published rate to it:
JavaScriptconst PEAK_VUS = 500; const MINUTES = 30; const RUNS_PER_MONTH = 8; const vuh = (PEAK_VUS * MINUTES) / 60; const monthlyVuh = vuh * RUNS_PER_MONTH; // Grafana Cloud k6 Pro: $19/month platform fee includes 500 VUh, then $0.150/VUh const k6 = 19 + Math.max(0, monthlyVuh - 500) * 0.15; // Artillery Cloud Team: $199/month flat const artillery = 199; // Gatling Enterprise Team: EUR 356/month billed annually, at the ECB rate for September 11, 2026 const gatling = 356 * 1.1592;
Running it prints the real spread:
Workload: 500 VUs x 30 min x 8 runs/month
= 250 VUh per run, 2000 VUh and 4h per month
Grafana Cloud k6 Pro $ 244.00/month 1500 VUh billed over the 500 included
Artillery Cloud Team $ 199.00/month flat, well under the 1000-report cap
Gatling Enterprise Team $ 412.68/month flat, 4h of 5h allowance used
Self-hosted OSS $ 0.00/month license only; compute billed separately
The shape matters more than the totals. k6 is the cheapest until it is not: double the peak users and the metered line doubles, while the flat plans do not move until you hit a cap. Gatling's Team plan allows 5 hours of testing a month, so this schedule uses four of them.
Grafana k6
Grafana k6 is the default recommendation for a team that wants load tests to look like code and live in CI. Grafana Labs acquired the k6 startup in 2021 and kept the engine open source.
What it does well: the engine is written in Go and tests are authored in JavaScript or TypeScript, the combination most teams want. You get Go-level efficiency on the load generator without asking a frontend developer to learn Scala, thresholds fail a build on a percentile rather than an average, and the same script runs locally and in Grafana Cloud without edits.
What it does not do: k6 is not a browser tool by default, and real browser sessions are a separate, more expensive mode. The AGPL-3.0 license is a genuine blocker at companies whose legal teams treat AGPL as radioactive, and cloud pricing is metered, so a runaway test is a runaway invoice.
License: AGPL-3.0 · Version: v2.2.0, released August 10, 2026 · Pricing: Free 500 VUh/month · Pro $19/month platform fee plus $0.150/VUh · Enterprise custom, scaling to 1 million concurrent VUs
Gatling
Gatling is the JVM-native option, most often found already installed at companies with a dedicated performance engineering function.
What it does well: tests are real code in Java, JavaScript or TypeScript, compiled and version controlled, and the reports are the most detailed here without paying extra. The open-source engine is a complete product rather than a trial.
What it does not do: the open-source edition has no orchestration across machines, which is exactly what the Enterprise plans sell. Prices are published in euros only, the entry plan allows one hour of testing per month, and the JVM build cycle makes the edit-run loop slower than k6 or Locust.
License: Apache-2.0 · Version: 3.15.1 · Pricing: Open source free · Basic €89/month, about $103, billed annually · Team €356/month, about $413 · Enterprise on request
Locust
Locust takes the opposite approach to configuration: your test is a Python class, and anything Python can do, your virtual user can do.
What it does well: the programming model is the simplest here. A user is a class, a task is a decorated method, and weighting traffic is an integer argument. It scales across worker processes and machines, and ships a live web UI non-engineers will actually watch during a test.
What it does not do: there is no commercial edition from the project itself, so distributed runs are infrastructure you own. Python's per-request overhead is higher than Go's or the JVM's, so very high request rates need more workers than an equivalent k6 test.
License: MIT · Version: 2.46.5, released September 7, 2026 · Pricing: Free, self-hosted
A complete Locust file, run against a local server with 50 users ramped at 25 per second for 20 seconds:
Pythonfrom locust import HttpUser, task, between class ShopUser(HttpUser): wait_time = between(0.1, 0.3) @task(3) def browse_catalog(self): self.client.get("/catalog.json", name="GET /catalog.json") @task def view_product(self): self.client.get("/product.json", name="GET /product.json")
Type Name # reqs # fails | Avg Min Max Med | req/s
GET GET /catalog.json 3588 0(0.00%)| 2 0 188 2 | 181.01
GET GET /product.json 1230 0(0.00%)| 2 0 157 2 | 62.05
Aggregated 4818 0(0.00%)| 2 0 188 2 | 243.06
Response time percentiles (approximated)
Type Name 50% 66% 75% 80% 90% 95% 98% 99% 99.9% 100% # reqs
Aggregated 2 2 3 3 4 4 6 10 160 190 4818
The 3:1 ratio between the endpoints comes straight from the @task(3) weight, and the p99.9 of 160 ms against a median of 2 ms is the interpreter, not the server.
Apache JMeter
Apache JMeter is the oldest tool here and the only one whose primary interface is a desktop GUI.
What it does well: protocol coverage nothing else here approaches. JMeter's own feature list covers HTTP and HTTPS, SOAP and REST, FTP, JDBC databases, LDAP, JMS middleware, and SMTP, POP3 and IMAP mail. To load test a message queue or a stored procedure rather than a JSON endpoint, this is often the only free answer, and it runs headless from the CLI.
What it does not do: the test plan is XML edited through a Swing GUI, which resists code review and merges badly. More importantly, the project has not cut a release since 5.6.3 on January 9, 2024, 20 months before September 13, 2026. The repository still receives commits, so it is maintained rather than abandoned, but a tool that cannot ship a release is not one to pick for new work.
License: Apache-2.0 · Version: 5.6.3, released January 9, 2024 · Pricing: Free, self-hosted
Artillery
Artillery treats "where do the load generators come from" as the product rather than an exercise for the reader.
What it does well: tests are YAML with JavaScript where you need logic, the lowest-friction format for a team that does not want to own a test framework. Its documentation states tests run on AWS Lambda, AWS Fargate or Azure Container Instances, so a distributed test is a flag rather than a cluster you maintain. Checks are declarative: a run fails when http.response_time.p95 crosses your number.
What it does not do: load originates in a cloud region rather than anywhere you choose, and Kubernetes is listed as planned rather than supported. The free tier caps tests at 30 minutes and 5 workers, below the workload priced above, so the real entry point is the $199 plan.
License: MPL-2.0 · Version: 2.0.34, released August 14, 2026 · Pricing: Free $0 · Team $199/month · Business $499/month · SSO and audit logs from $1,199/month
Side by Side
| Tool | Scripting format | Entry price | Self-host | License |
|---|---|---|---|---|
| Grafana k6 | JavaScript, TypeScript | Free 500 VUh, then $0.150/VUh | Yes | AGPL-3.0 |
| Gatling | Java, JavaScript, TypeScript | €89/month, about $103 | Yes | Apache-2.0 |
| Locust | Python | $0 | Yes | MIT |
| Apache JMeter | XML via GUI | $0 | Yes | Apache-2.0 |
| Artillery | YAML plus JavaScript | $0, Team $199/month | Yes | MPL-2.0 |
How to Choose Without Running the Wrong Test
- Write down the peak, the duration and the frequency first. Those three numbers are the only inputs to the VUh formula and they set the price on every metered plan. Run the script above on your own numbers before reading a pricing page.
- Settle your legal position on AGPL before you fall in love with k6. It is the most common late-stage blocker here, and a five-minute question rather than a rewrite to discover.
- Pick the language your on-call engineers already read. A load test only one person can modify stops being run within two quarters, which matters more than any benchmark difference between engines.
- Decide who owns the load generators. Self-hosting Locust or JMeter is free in license and not in time. Artillery's serverless model and Gatling's Enterprise orchestration both exist to remove that job.
- Confirm the protocol before the tool. To test JMS, JDBC or SMTP rather than HTTP, JMeter's protocol list makes this decision for you.
Which One Should You Actually Use?
A product team putting load tests in CI for the first time: Grafana k6. JavaScript tests, thresholds that fail a build on a percentile, and a free tier covering a real weekly test. Settle the AGPL question first.
A Python shop: Locust. The programming model is obvious on day one, and 11.3 million monthly PyPI downloads means your question is already answered somewhere.
A team that wants distributed load without operating it: Artillery. The $199 Team plan beats the metered k6 month above, and Lambda and Fargate execution removes the generator fleet.
An enterprise with a JVM stack and performance engineers: Gatling. Detailed reports and compiled, reviewable tests justify the euro invoice, and the open-source engine is complete without the Enterprise features.
Anyone testing JMS, JDBC, LDAP or mail: Apache JMeter, with the caveat that its last release was January 2024.
Conclusion
What changed this year is that free tiers got good enough to remove the excuse: a 500 VUh monthly allowance on Grafana Cloud covers a 500-user, 30-minute test twice a month at no cost, and Locust and JMeter stay free at any scale you will operate. What has not changed is that metered plans reward small, frequent tests and punish the annual pre-launch soak test, which is the one most teams still run.
Before renewing any of these, ask one question: what peak did we test at last quarter, and was it above or below the traffic we actually served? If it was below, you are paying for reassurance rather than information.
Related DevToolLab Tools
- cURL Command Generator - build the exact request, headers and body you are about to multiply by 500 virtual users.
- HTTP Cache Header Analyzer - check whether your load reaches the origin at all, because a cached response makes a load test measure your CDN.
- HTTP Status Checker - confirm every endpoint answers correctly before you spend virtual user hours discovering a 301.
- Stack Trace Parser - turn the exceptions a service throws at peak into a frame table that separates your code from the framework's.
Related Guides
- Beyond Postman: The Best API Testing Tools for Developers in 2026 covers the functional side of the same endpoints, a different job from load testing and worth getting right first.
- Best CI/CD Tools in 2026 matters because a load test that is not in a pipeline is a load test nobody runs twice.
- OpenTelemetry for Node.js shows how to instrument the service so a failed threshold points at a span instead of a shrug.
- Datadog Alternatives is the companion decision: the load test says something broke, the observability stack says where.