k6

Developer-centric load testing tool by Grafana Labs. Write tests in JavaScript or TypeScript, run them on a blazing-fast Go runtime, define pass/fail thresholds, and integrate directly into your CI/CD pipeline — no GUI required.

What is k6?

k6 (pronounced "kay-six") is an open-source load testing tool built by Grafana Labs and the community. Unlike older tools that require XML configuration or a GUI, k6 tests are plain JavaScript or TypeScript files that live in your repo. The runtime is written in Go, not Node.js — meaning k6 can push enormous load from a single machine with minimal memory overhead.

k6 is opinionated about the developer experience: tests are code, results are structured, and pass/fail criteria (thresholds) are defined alongside the test logic. This makes k6 a natural fit for modern engineering teams that treat performance as part of the CI/CD pipeline rather than a one-off pre-production activity.

Key Features

• JavaScript/TypeScript tests — familiar language, ES modules, IntelliSense support; tests version-controlled like application code
• Go runtime — not Node.js; extremely low memory per VU enables high concurrency on modest hardware
• Built-in protocols — HTTP/1.1, HTTP/2, WebSockets, and gRPC out of the box
• Virtual Users + executors — constant VUs, ramping VUs, constant arrival rate, ramping arrival rate, and more for realistic load shapes
• Thresholds — define SLO-based pass/fail criteria (e.g. p(95)<500) that fail CI on breach
• Custom metrics — Counter, Gauge, Rate, Trend for domain-specific instrumentation
• xk6 extensions — build custom k6 binaries with Kafka, Redis, browser, SQL, and more
• Output integrations — stream metrics to Grafana Cloud, InfluxDB, Prometheus, Datadog, or JSON/CSV
• k6 browser — bundled Chrome DevTools Protocol module for real browser performance testing

Installation

# macOS (Homebrew)
brew install k6

# Windows (Chocolatey)
choco install k6

# Windows (winget)
winget install k6 --source winget

# Docker
docker pull grafana/k6

# Linux (Debian/Ubuntu)
sudo gpg -k
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update && sudo apt-get install k6

# Verify installation
k6 version

Quick Start: Basic Load Test

A k6 script exports a default function (the "virtual user loop") and an options object for configuration. The example below ramps to 20 VUs, holds for 1 minute, then ramps down — and fails if the p95 response time exceeds 500ms.

// script.js — a basic k6 load test
import http from 'k6/http';
import { check, sleep } from 'k6';

// Test configuration: ramp up, hold, ramp down
export const options = {
  stages: [
    { duration: '30s', target: 20 },  // ramp up to 20 VUs over 30s
    { duration: '1m',  target: 20 },  // hold at 20 VUs for 1 minute
    { duration: '10s', target: 0  },  // ramp down to 0 VUs
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],   // 95th percentile must be < 500ms
    http_req_failed:   ['rate<0.01'],   // error rate must be < 1%
  },
};

export default function () {
  const res = http.get('https://test.k6.io');

  check(res, {
    'status is 200':          (r) => r.status === 200,
    'response time < 500ms':  (r) => r.timings.duration < 500,
  });

  sleep(1); // think time between iterations
}

Run it with: k6 run script.js

Advanced: Custom Metrics & Authentication

Use the k6/metrics API to track domain-specific values. Define a Trend for login duration and a Rate for login failures, then set thresholds on them.

// Advanced: authenticated POST + JSON parsing + custom metrics
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

const loginFailRate = new Rate('login_failures');
const loginDuration = new Trend('login_duration_ms');

export const options = {
  vus: 50,
  duration: '2m',
  thresholds: {
    login_failures:    ['rate<0.05'],
    login_duration_ms: ['p(99)<1000'],
    http_req_duration: ['p(95)<400', 'p(99)<800'],
  },
};

export default function () {
  const payload = JSON.stringify({ username: 'testuser', password: 'secret' });
  const params  = { headers: { 'Content-Type': 'application/json' } };

  const res = http.post('https://api.example.com/auth/login', payload, params);

  const success = check(res, {
    'login status 200': (r) => r.status === 200,
    'has access_token':  (r) => JSON.parse(r.body).access_token !== undefined,
  });

  loginFailRate.add(!success);
  loginDuration.add(res.timings.duration);

  sleep(Math.random() * 2 + 1); // random think time 1-3s
}

Executor Types

k6 scenarios let you mix different executor types in a single test. Use constant-arrival-rate to model steady-state throughput independent of response time, or ramping-arrival-rate to simulate traffic spikes.

// Executor types for realistic load shapes
export const options = {
  scenarios: {
    // Constant arrival rate — independent of response time
    constant_load: {
      executor: 'constant-arrival-rate',
      rate:     100,         // 100 requests per second
      duration: '1m',
      preAllocatedVUs: 20,
      maxVUs: 50,
    },

    // Ramping arrival rate — simulate traffic spikes
    spike_test: {
      executor: 'ramping-arrival-rate',
      startRate: 10,
      stages: [
        { target: 500, duration: '30s' },  // spike to 500 rps
        { target: 10,  duration: '30s' },  // recover
      ],
      preAllocatedVUs: 50,
      maxVUs: 200,
    },

    // Per-VU iterations — each VU runs exactly N times
    smoke_test: {
      executor:    'per-vu-iterations',
      vus:         5,
      iterations:  10,
      maxDuration: '1m',
    },
  },
};

CI/CD Integration

k6 exits with a non-zero code when thresholds are breached, making it a drop-in CI gate. Grafana provides an official grafana/k6-action for GitHub Actions.

# GitHub Actions — run k6 as part of CI pipeline
name: Load Test

on:
  push:
    branches: [main]

jobs:
  k6_load_test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run k6 load test
        uses: grafana/[email protected]
        with:
          filename: tests/load/api.js
        env:
          BASE_URL: ${{ secrets.STAGING_URL }}

      # Or run k6 directly
      - name: Install k6
        run: |
          curl https://github.com/grafana/k6/releases/download/v0.51.0/k6-v0.51.0-linux-amd64.tar.gz -L | tar xvz
          sudo cp k6-v0.51.0-linux-amd64/k6 /usr/local/bin

      - name: Run tests
        run: k6 run --out json=results.json tests/load/api.js

k6 vs JMeter vs Locust

Pros and Cons