autocannon

Ultra-fast HTTP/1.1 benchmarking tool built for Node.js. Powered by uWebSockets, it measures latency percentiles (p50, p90, p99), requests per second, and throughput — from the CLI or embedded directly in your Node.js scripts and CI pipelines.

What is autocannon?

autocannon is an open-source HTTP benchmarking tool written entirely in Node.js by Matteo Collina, a Node.js core contributor. It uses uWebSockets to generate high-throughput load against HTTP/1.1 and HTTPS endpoints, making it significantly faster than tools implemented in pure JavaScript.

Unlike heavier load-testing platforms, autocannon focuses on raw HTTP performance measurement: how fast does your server respond, what are the tail latencies, how many requests per second can it sustain? It works as a command-line tool for quick benchmarks and as a Node.js module for embedding performance gates in automated test suites and CI pipelines.

Key Features

• Ultra-fast engine — built on uWebSockets for maximum request throughput from a single Node.js process
• Configurable load — set concurrent connections, pipelining factor, duration, or total request count
• Latency percentiles — reports p50, p75, p90, p97.5, p99, p99.9, p99.99 via HDR histograms
• HTTP & HTTPS — benchmarks both plain HTTP and TLS-secured HTTPS endpoints
• Programmatic API — use autocannon() in Node.js scripts, tests, and CI jobs
• POST / custom methods — set method, headers, and body for any HTTP verb
• HTTP pipelining — send multiple requests per connection without waiting for responses
• JSON output — machine-readable results for dashboards and performance regression tracking

Installation

# Install globally
npm install -g autocannon

# Or add to a project as a dev dependency
npm install --save-dev autocannon

# Verify installation
autocannon --version

CLI Usage

The CLI covers most benchmarking scenarios: set -c for connections, -d for duration in seconds, -m for HTTP method, -H for headers, and -b for a request body.

# Benchmark a GET endpoint for 10 seconds with 10 connections
autocannon -c 10 -d 10 http://localhost:3000/api/users

# POST with JSON body and custom header
autocannon -c 20 -d 30 \
  -m POST \
  -H "Content-Type: application/json" \
  -b '{"name":"test","email":"[email protected]"}' \
  http://localhost:3000/api/users

# 100 connections, 1000 total requests (instead of duration)
autocannon -c 100 -a 1000 http://localhost:3000/

# Enable HTTP pipelining (4 requests per connection)
autocannon -c 10 -p 4 -d 10 http://localhost:3000/

# Output results as JSON (useful for CI pipelines)
autocannon -c 10 -d 5 --json http://localhost:3000/ > results.json

# Benchmark with a custom Authorization header
autocannon -c 50 -d 20 \
  -H "Authorization: Bearer " \
  https://api.example.com/protected

Programmatic API

Import autocannon as a Node.js module to run benchmarks from scripts, Mocha/Jest test files, or custom tooling. The returned Promise resolves with a structured results object containing all latency, throughput, and error statistics.

// benchmark.js — programmatic API
const autocannon = require('autocannon');

async function run() {
  const result = await autocannon({
    url: 'http://localhost:3000/api/items',
    connections: 20,       // concurrent connections
    pipelining: 1,         // HTTP pipelining factor
    duration: 10,          // seconds
    method: 'GET',
    headers: {
      'accept': 'application/json',
    },
  });

  // result contains full latency/throughput statistics
  console.log('Requests/sec:', result.requests.average);
  console.log('Throughput:  ', result.throughput.average, 'bytes/sec');
  console.log('Latency p50: ', result.latency.p50, 'ms');
  console.log('Latency p99: ', result.latency.p99, 'ms');
  console.log('Errors:      ', result.errors);
}

run();

CI Performance Gates

Combine the programmatic API with process.exit(1) to fail a CI build when latency or throughput regresses past defined thresholds. Run this script after deploying to a staging environment to catch performance regressions before they reach production.

// ci-benchmark.js — fail the build if p99 latency exceeds threshold
const autocannon = require('autocannon');

async function benchmark() {
  const result = await autocannon({
    url: process.env.TARGET_URL || 'http://localhost:3000/',
    connections: 10,
    duration: 10,
  });

  const p99 = result.latency.p99;
  const rps  = result.requests.average;

  console.log(`p99 latency: ${p99}ms | RPS: ${rps}`);

  if (p99 > 200) {
    console.error(`FAIL: p99 ${p99}ms exceeds 200ms threshold`);
    process.exit(1);
  }

  console.log('PASS: performance within acceptable thresholds');
}

benchmark();

autocannon vs wrk vs ab

Pros and Cons