Artillery is a modern, powerful & easy-to-use performance testing toolkit. Use it to ship scalable applications that stay performant & resilient under high load.
Artillery prioritizes developer productivity and happiness, and follows the "batteries-included" philosophy.
Artillery was designed with best practices for modern production-engineering in mind. Test at cloud-scale, test any stack, and go from zero to production-grade testing fast.
|Test at cloud-scale||Distributed load testing built in. Run distributed multi-region load tests using AWS Lambda or AWS Fargate without managing any infrastructure|
|Test any stack||Test HTTP APIs, WebSocket and Socket.io services, or complex web apps with real browsers|
|Go from zero to production-grade fast||Designed to be easy to start with, with extensions and plugins for common tasks and integrations with monitoring, o11y and CI/CD|
|Extensible||Extend Artillery and build custom integrations with Node.js|
|Scalable and cost-efficient||Run large-scale load tests from your own AWS account with AWS Lambda or serverless AWS Fargate cluster|
|Permissive open source||Licensed under MPL-2.0 to make building on top of Artillery easy for platform and SQA teams|
You can use Artillery to run two types of performance tests:
- Tests that put load on a system, i.e. load tests, stress tests, and soak tests
- Tests that verify that a system is working as expected, i.e. continuous functional tests, also known by a number of other names such as: synthetic monitoring, semantic monitoring, production scripted testing, and continuous verification. Think
pingon steroids - automated probes running continuously against services & APIs to test key user journeys.
Artillery is designed for testing backend systems, such as API services, ecommerce backends, chat systems, game backends, databases, message brokers and queues, and anything else that can be communicated with over a network.
It can be used to test any backend regardless of what protocol it speaks or what language it's written in. Artillery supports HTTP, WebSocket, and Socket.io out of the box, and many additional protocols such as HLS, Kinesis, and Kafka via plugins. Support for additional protocols can be added via Artillery's plugin interface.
Yes, Artillery can be used to run Playwright-based scripts as either load tests or synthetic checks.
Artillery is typically used across teams responsible for delivery, testing, and operating production backend systems: from application developers, to test & QA engineers, and ops/SREs.
Artillery is used in a large variety of scenarios, which typically include:
- Running ad-hoc load tests against individual APIs or microservices as part of a development process to explore their performance characteristics, and make performance optimizations if needed (e.g. preventing memory leaks or optimizing CPU-heavy code)
- Running tests against staging/feature environments as part of a CI/CD pipeline to catch performance regressions early, and to verify SLOs
- Large-scale load tests before production releases of new services, or to prepare applications and infrastructure for heavy traffic, such as Black Friday/Cyber Monday traffic
- Adding synthetic traffic in production to maintain a margin of safety against traffic spikes
- Running synthetic monitoring against key APIs from multiple geographical locations to verify that key transactions & flows work as expected, and alert if anything breaks
Load and smoke testing in one package - Re-use the same scenarios to run either load or functional tests. Use assertions and expectations on the responses, and easily extract and store data from responses to re-use in subsequent requests.
Batteries-included -you can test any system regardless of the protocol it speaks or tech stack it's built upon. HTTP, Socket.io, and WebSockets are supported out of the box, with support for many other protocols available via plugins (gRPC (opens in a new tab), Kafka (opens in a new tab), Kinesis (opens in a new tab), SQL (opens in a new tab), Lambda (opens in a new tab)). A number of monitoring systems are supported out of the box (Datadog, InfluxDB, Statsd), with third-party plugins providing support for other systems.
Because Artillery is built on top of Node.js, you can use any of the thousands of modules available via
npm in your plugins to save time.
Artillery ships with several plugins to make common tasks easier, and there's a number of ready-to-use community plugins available.
Please see Integrations (opens in a new tab) on our website for a full list of integrations and add-ons.
Artillery's readable YAML-based test scripts encourage collaboration across teams and functions. No knowledge of any specific programming language is needed to read and understand Artillery scripts. We believe that performance is everybody's job and YAML makes it easier for everyone to contribute.
Run your tests at scale - Artillery supports distributed load testing at scale with AWS Lambda or AWS Fargate. It's easy to go from running a test on a laptop, to running geographically distributed massively parallel load tests from your team's own AWS account, without managing any infrastructure.
Artillery consists of Artillery CLI and Artillery Dashboard. The Artillery CLI is a free, open source tool, which can be used to write and run load tests, with support for serverless distributed load testing via AWS Lambda or AWS Fargate out of the box. Artillery Dashboard (opens in a new tab) is a hosted dashboard designed for teams that run load tests frequently and need a solution for visual reporting, collaboration, and performance analysis.
Our mission is to help development teams ship performant, resilient, and scalable software systems.
We believe that software is eating the world (opens in a new tab). Complex software systems underpin all aspects of our daily lives. There are no industries that don't rely on software anymore - hundreds of software systems were involved in getting your breakfast cereal to your cupboard for example.
At the same time, software systems are only getting more complex, and complexity is the enemy of performance and reliability. As our dependence on software system grows, the importance of shipping performant and reliable software grows along with it.
We believe that performance is a feature. Software which is fast and reliable makes for happier users, and happier users make for more revenue.
We believe that performance is everyone's job and requires cross-functional collaboration between product owners, developers, QA engineers, ops & SREs.
Artillery prioritizes developer productivity above everything else. We believe that performance tests should be as easy to write and run as possible. Every product decision in Artillery is viewed through the lens of developer experience and a batteries-included philosophy.