Grafana Dashboards

Grafana provides powerful visualization capabilities for k6 test results. By combining k6 metrics with application and system metrics in a single dashboard, you can quickly identify performance bottlenecks and analyze trends over time.

Benefits

Visualizing k6 results in Grafana offers several advantages:

Real-Time Monitoring

Watch test results as they stream in, identifying issues immediately

Historical Analysis

Compare test runs over time to track performance trends

Correlation

View k6 metrics alongside system metrics (CPU, memory) to find root causes

Customization

Create dashboards tailored to your specific needs and metrics

Grafana dashboard showing k6 results correlated with system metrics

Prerequisites

To visualize k6 results in Grafana, you need:

Grafana - Either self-hosted or Grafana Cloud
Storage backend - A database to store k6 metrics (InfluxDB, Prometheus, etc.)
k6 output configuration - Stream metrics from k6 to your backend

Quick Start

Here’s a complete example using Docker Compose with InfluxDB and Grafana:

Create docker-compose.yml

docker-compose.yml

version: '3.8'
services:
  influxdb:
    image: influxdb:2.7
    ports:
      - "8086:8086"
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=adminpass
      - DOCKER_INFLUXDB_INIT_ORG=myorg
      - DOCKER_INFLUXDB_INIT_BUCKET=k6
    volumes:
      - influxdb-data:/var/lib/influxdb2

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_AUTH_ANONYMOUS_ENABLED=true
      - GF_AUTH_ANONYMOUS_ORG_ROLE=Admin
    volumes:
      - grafana-data:/var/lib/grafana
    depends_on:
      - influxdb

volumes:
  influxdb-data:
  grafana-data:

Start services

docker-compose up -d

Build k6 with InfluxDB extension

xk6 build --with github.com/grafana/xk6-output-influxdb

Run k6 test

K6_INFLUXDB_ORGANIZATION=myorg \
K6_INFLUXDB_BUCKET=k6 \
K6_INFLUXDB_TOKEN=your-token \
./k6 run --out xk6-influxdb script.js

Access Grafana

Open http://localhost:3000 and import a pre-built dashboard

Pre-Built Dashboards

Several k6 outputs include ready-to-use Grafana dashboards:

InfluxDB
Prometheus
Grafana Cloud Prometheus
TimescaleDB
AWS Timestream

Output: grafana/xk6-output-influxdbDashboards:

k6 Test Result Dashboard
k6 Test Comparison Dashboard

Import:

Download dashboards from GitHub
In Grafana: Dashboards → Import → Upload JSON file
Select your InfluxDB data source

Features:

Real-time metrics visualization
Request rate and error rate
Response time percentiles
Virtual user activity
Data transfer rates

Output: Prometheus Remote WriteDashboard: k6 PrometheusImport:

In Grafana: Dashboards → Import
Enter dashboard ID: 19665
Select your Prometheus data source

For Native Histograms:

Dashboard ID: 18030
Enables advanced percentile calculations

Run test:

K6_PROMETHEUS_RW_SERVER_URL=http://localhost:9090/api/v1/write \
k6 run --out experimental-prometheus-rw script.js

Output: Grafana Cloud PrometheusDashboard: k6 PrometheusImport: Dashboard ID 19665Run test:

K6_PROMETHEUS_RW_SERVER_URL=https://prometheus-prod-01-eu-west-0.grafana.net/api/prom/push \
K6_PROMETHEUS_RW_USERNAME=<username> \
K6_PROMETHEUS_RW_PASSWORD=<password> \
k6 run --out experimental-prometheus-rw script.js

Dashboard Examples

Standard Metrics Dashboard

A typical k6 dashboard includes these panels: Performance Overview:

Response time (p50, p95, p99)
Request rate (requests/second)
Error rate (%)
Virtual users (active)

HTTP Metrics:

Request duration breakdown (blocked, connecting, TLS, sending, waiting, receiving)
Failed requests over time
Requests by status code

System Impact:

Data sent/received
Iterations per second
Iteration duration

Thresholds & Checks:

Threshold violations
Check success rate

Correlation Dashboard

Combine k6 metrics with application metrics:

┌─────────────────────────────────────────────────┐
│ k6 Response Time (p95)          │ CPU Usage (%) │
│ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │ ━━━━━━━━━━━━ │
└─────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────┐
│ k6 Request Rate        │ Database Connections   │
│ ━━━━━━━━━━━━━━━━━━━━ │ ━━━━━━━━━━━━━━━━━━━━ │
└─────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────┐
│ k6 Error Rate          │ Application Logs       │
│ ━━━━━━━━━━━━━━━━━━━━ │ [ERROR] Connection...│
└─────────────────────────────────────────────────┘

This allows you to:

Identify when high load causes CPU spikes
Correlate response time degradation with database saturation
Match error rates with application errors

Creating Custom Dashboards

Build dashboards tailored to your specific needs:

InfluxDB Query
Prometheus Query
Panel Configuration

Response time percentiles:

from(bucket: "k6")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "http_req_duration")
  |> aggregateWindow(every: 10s, fn: mean)

Request rate:

from(bucket: "k6")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "http_reqs")
  |> derivative(unit: 1s, nonNegative: true)

Error rate:

from(bucket: "k6")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "http_req_failed")
  |> map(fn: (r) => ({ r with _value: r._value * 100.0 }))

Response time percentiles:

histogram_quantile(0.95, 
  rate(k6_http_req_duration_seconds_bucket[5m])
)

Request rate:

rate(k6_http_reqs_total[1m])

Error rate:

rate(k6_http_req_failed_total[1m]) / 
rate(k6_http_reqs_total[1m]) * 100

Virtual users:

k6_vus

Best Practices

Use appropriate time ranges

For live tests: Last 5-15 minutes
For analysis: Full test duration
For trends: Days or weeks

Set refresh interval to 5-10 seconds for real-time monitoring.

Organize with variables

Create dashboard variables for:

Test run ID or tag
Scenario name
Environment (dev, staging, prod)

This makes dashboards reusable across different tests.

Add annotations

Mark important events on your graphs:

Deployment times
Configuration changes
Threshold violations

Use Grafana’s annotation features or log them as metrics.

Set meaningful alerts

Configure alerts for:

Error rate exceeds threshold
Response time degradation
Test failures

Send notifications to Slack, PagerDuty, or email.

Complete Example

Here’s a full workflow with InfluxDB and Grafana:

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 10 },
    { duration: '3m', target: 10 },
    { duration: '1m', target: 0 },
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],
    http_req_failed: ['rate<0.01'],
  },
};

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);
}

#!/bin/bash

# Build k6 with InfluxDB extension
xk6 build --with github.com/grafana/xk6-output-influxdb

# Start InfluxDB and Grafana
docker-compose up -d

# Wait for services to be ready
sleep 10

# Run test
K6_INFLUXDB_ORGANIZATION=myorg \
K6_INFLUXDB_BUCKET=k6 \
K6_INFLUXDB_TOKEN=my-token \
K6_INFLUXDB_ADDR=http://localhost:8086 \
./k6 run --out xk6-influxdb test.js

echo "View results at http://localhost:3000"

{
  "dashboard": {
    "title": "k6 Load Test Results",
    "panels": [
      {
        "title": "Response Time",
        "type": "graph",
        "targets": [
          {
            "query": "from(bucket: \"k6\") |> range(start: -1h) |> filter(fn: (r) => r._measurement == \"http_req_duration\")"
          }
        ]
      },
      {
        "title": "Request Rate",
        "type": "graph",
        "targets": [
          {
            "query": "from(bucket: \"k6\") |> range(start: -1h) |> filter(fn: (r) => r._measurement == \"http_reqs\")"
          }
        ]
      }
    ]
  }
}

Grafana Cloud k6

For a fully managed solution, Grafana Cloud k6 provides:

Automatic metric storage and retention
Pre-built dashboards optimized for k6
Test management and scheduling
Team collaboration features
Cloud execution for distributed tests
No infrastructure to manage

Grafana Cloud k6 includes specialized views beyond standard Grafana dashboards, designed specifically for load testing workflows.

Community Dashboards

Explore more dashboards created by the community:

Next Steps

Real-Time Streaming

Learn how to stream metrics to your backend

Web Dashboard

Use the built-in k6 web dashboard

Grafana Docs

Explore Grafana’s documentation

InfluxDB Extension

View the InfluxDB output extension

Using k6

Testing Guides

Browser Testing

Results & Visualization

Grafana Dashboards

Grafana Dashboards

Benefits

Real-Time Monitoring

Historical Analysis

Correlation

Customization

Prerequisites

Quick Start

Pre-Built Dashboards

Dashboard Examples

Standard Metrics Dashboard

Correlation Dashboard

Creating Custom Dashboards

Best Practices

Complete Example

Grafana Cloud k6

Community Dashboards

Next Steps

Real-Time Streaming

Web Dashboard

Grafana Docs

InfluxDB Extension

​Grafana Dashboards

​Benefits

Real-Time Monitoring

Historical Analysis

Correlation

Customization

​Prerequisites

​Quick Start

​Pre-Built Dashboards

​Dashboard Examples

​Standard Metrics Dashboard

​Correlation Dashboard

​Creating Custom Dashboards

​Best Practices

​Complete Example

​Grafana Cloud k6

​Community Dashboards

​Next Steps

Real-Time Streaming

Web Dashboard

Grafana Docs

InfluxDB Extension

Grafana Dashboards

Benefits

Prerequisites

Quick Start

Pre-Built Dashboards

Dashboard Examples

Standard Metrics Dashboard

Correlation Dashboard

Creating Custom Dashboards

Best Practices

Complete Example

Grafana Cloud k6

Community Dashboards

Next Steps