Artillery review
Curator verified · Hands-onThe short version
Artillery is the JavaScript load tool that leans on YAML.
Scenarios are declarative, custom logic drops into Node.js hooks, and the Playwright integration lets one test mix API calls with real browser sessions. Running distributed from your own AWS Lambda or Fargate account is a distinctive strength. Per-worker efficiency trails k6, and the best reporting and history live in Artillery Cloud rather than the open-source CLI.
- Strong
- Scripting & extensibility, Scale & distribution, CI/CD & automation, Cost & licensing
- Adequate
- Protocol coverage, Reporting & analysis
- Limited
- AI features
- Best for
- You want declarative YAML scenarios with Node.js escape hatches
- License
- Open Source
- Pricing
- Free open-source core; commercial cloud features available.
- Deployment
- Self-hosted
- Scripting / languages
- JavaScript, TypeScript
- First release
- 2016
Artillery review: the full verdict
Hands-onWhat Artillery is
Artillery is a Node.js load testing tool where the scenario is declared in YAML and custom logic lives in JavaScript or TypeScript processors. It targets HTTP, WebSocket, Socket.IO, gRPC, and Kinesis, and its Playwright engine lets one test mix API calls with real browser sessions.
The most distinctive feature is distribution: Artillery can run a test across AWS Lambda functions, Fargate tasks, or Azure Container Instances in your own cloud account, with no injector fleet to manage and no vendor hosting your traffic.
In practice
A first test is a YAML file with a target, a phases block describing arrival rate over time, and a scenario with a flow of requests. It is readable enough that a product owner can follow it in a pull request. When you need logic, you point the config at a processor file and write plain JavaScript with access to the full npm ecosystem, something k6 cannot offer.
The ensure block turns your SLOs into pass or fail conditions with a non-zero exit code, so CI integration is straightforward. Running artillery run-lambda with your AWS credentials fans the test out across Lambda workers and aggregates results back, and it worked on the first try for me.
Where it falls short
Per-worker efficiency trails k6 and Gatling because each worker is a Node.js process; you compensate by adding workers, which is easy but not free. Open source reporting is a JSON file and a basic report; trend history and dashboards live in Artillery Cloud. YAML gets awkward once branching logic grows, and you find yourself moving more into processors. The community is smaller than k6 or JMeter, so answers take longer to find.
AI features
Artillery has no AI-assisted authoring or analysis today; Artillery Cloud is focused on reporting and collaboration. Because scenarios are YAML and JavaScript, general coding assistants can help, but nothing is built in.
Bottom line: Artillery is the right pick when you want declarative scenarios with Node.js escape hatches and serverless distribution from your own AWS account. If raw efficiency per injector or rich open source reporting is the priority, k6 or Gatling are better fits.
Scorecard
Qualitative, 7 dimensionsStrong, Adequate, or Limited on each dimension. No numeric scores and no averaging, because a Limited rating on the one dimension you depend on outweighs any total.
How we rate: methodology. Ratings are refreshed with each hands-on pass, not on a fixed schedule.
Pros & cons
What stood out during testing, and what got in the way.
Pros
- Declarative scenarios are easy to read and review
- Distributed runs without managing injector fleets
- Playwright engine for realistic browser load
- Full npm ecosystem available in processors
Cons
- Node.js worker efficiency is below Go or JVM tools
- Open-source reporting is minimal
- YAML gets awkward for complex branching logic
- Smaller community than k6 or JMeter
Who it's for
A ten-second answer for teams shortlisting tools.
Pick Artillery when
- You want declarative YAML scenarios with Node.js escape hatches
- Serverless distribution from your own AWS account appeals
- Browser and API load need to run in the same test
Skip Artillery when
- Maximum efficiency per injector is the priority
- You want to avoid Node.js in the toolchain
- Rich reports are needed without a cloud subscription
Getting started
Minutes to first scriptAn hour for a first YAML scenario; processors and distributed runs take a day.
Review FAQ
Answer-shapedIs Artillery worth it in 2026?
Artillery is the JavaScript load tool that leans on YAML. js hooks, and the Playwright integration lets one test mix API calls with real browser sessions. You want declarative YAML scenarios with Node.js escape hatches That makes it worth considering when the team's workload and authoring model match these strengths.
When should you pick Artillery?
You want declarative YAML scenarios with Node.js escape hatches Serverless distribution from your own AWS account appeals Browser and API load need to run in the same test Together, these are the clearest signals that Artillery fits the project. Compare the current documentation, operating model, and total cost with the project requirements before making a final decision.
When should you skip Artillery?
Maximum efficiency per injector is the priority You want to avoid Node.js in the toolchain Rich reports are needed without a cloud subscription Treat these constraints as reasons to compare alternatives before committing to Artillery. Compare the current documentation, operating model, and total cost with the project requirements before making a final decision.
Does Artillery have AI features?
No native AI features; Artillery Cloud focuses on reporting. Check the current product documentation before relying on these capabilities in production. Compare the current documentation, operating model, and total cost with the project requirements before making a final decision.