API Load Testing and Performance Analysis: Grafana k6 vs Apache JMeter

API load test scenarios, metrics, and comparison with k6 and JMeter

This article explains how to run load tests on APIs without extensive experience, using the open-source tools k6 and JMeter.

• API: An interface that enables communication between applications.
• Load testing: Tests that evaluate how an application performs under a given load; they measure resilience, speed, and overall performance.
• k6: An open-source load-testing tool; JavaScript-based scripts, console-driven. It simulates realistic API traffic and measures how your system responds under load.
• JMeter: An open-source, Java-based load-testing tool; scenarios are defined via GUI or XML. It simulates realistic user behavior.

We will run the same kinds of tests with both k6 and JMeter and compare them.

Grafana k6 and Apache JMeter Comparison

Feature	JMeter	k6
Language and style	Java	JavaScript
Setup and startup	JRE, GUI-based	Node.js, console-based
Performance and scalability	Heavy load tests, higher resource usage	Lightweight, scalable
Scenario definition	XML, GUI or manual	Code in JavaScript
Distributed testing	Broad support	k6 Cloud or custom setups
Reporting	GUI, graphs, Grafana/InfluxDB	Console, k6 Cloud, integrations
Community	Large user base	Rapidly growing

JMeter’s UI offers graphical reports, Backend listener, and Grafana/InfluxDB. k6 is console-based but can be used with many visualization options and Grafana integration.

k6 Basic Test Scenarios

Below are examples for load, endurance, stress, and performance-optimization scenarios targeting API endpoints.

Load test

Simulates many users connecting at the same time.

import http from 'k6/http';
import { sleep } from 'k6';
export default function () {
  const numberOfUsers = 100;
  Array.from({ length: numberOfUsers }, (_, index) => {
    http.get(`https://example.com/page${index}`);
    sleep(1);
  });
}

Endurance test

Simulates the application running stably under a constant load for a period.

import http from 'k6/http';
import { sleep } from 'k6';
export default function () {
  while (1) {
    http.get('https://example.com');
    sleep(1);
  }
}

Stress test

Simulates sudden traffic spikes or fast changes in user count.

import http from 'k6/http';
import { sleep } from 'k6';
export default function () {
  const numberOfUsers = __VU * 10;
  Array.from({ length: numberOfUsers }, (_, index) => {
    http.get(`https://example.com/page${index}`);
    sleep(0.1);
  });
}

Example k6 scenario (staged load)

import http from 'k6/http';
import { check, sleep } from 'k6';
export let options = {
  stages: [
    { duration: '30s', target: 500 },
    { duration: '1m', target: 50 },
    { duration: '30s', target: 0 },
  ],
};
export default function () {
  let methods = ['GET', 'POST', 'PUT', 'DELETE'];
  let method = methods[Math.floor(Math.random() * methods.length)];
  let endpoints = [
    'https://example.com/k6_load_test/get',
    'https://example.com/k6_load_test/post',
    'https://example.com/k6_load_test/put',
    'https://example.com/k6_load_test/delete',
  ];
  let endpoint = endpoints[Math.floor(Math.random() * endpoints.length)];
  let res = http.request(method, endpoint);
  check(res, { 'is status 200': (r) => r.status === 200 });
}

Run with: k6 run k6_load_test.js

k6 result metrics (summary): http_reqs (total requests), http_req_duration (response time), http_req_failed, iterations, vus/vus_max, checks, data_received/data_sent, p(90)/p(95) (percentiles). These help you assess your API’s behavior under load and find bottlenecks. k6 results can be visualized together with system metrics via Prometheus and Grafana.

Installation: k6 installation guide (Windows, Mac, Linux).

JMeter Basic Test Scenarios

In JMeter you configure Threads (number of simulated users), Loop count, and Ramp-up Period (time to start all threads).

API performance test: Threads = number of concurrent requests to the API (e.g. 500); Loop = how many times each user repeats; Ramp-up = time to start all users.

Additional scenarios: (1) Increase request count to simulate load, (2) Maximum load test, (3) Long-duration load test, (4) Different request types (GET, POST, PUT, DELETE), (5) Average response time test, (6) Error-handling test, (7) Scheduled tests with a timer.

JMeter can be run from the GUI (Run) or from the command line; results can be written to CSV:

jmeter -n -t /path/to/TEST_NAME.jmx -l /path/to/RECORD_NAME.csv

JMeter result metrics (summary): summary (total requests), total time, average requests/second, average/min/max response time, error count and percentage, active/started/finished request counts.

Installation: JMeter installation guide (Windows, Mac, Linux).

Comparing JMeter and k6 Performance Test Results

Feature	JMeter	k6
Test environment	Standalone test	Local environment
Test duration	e.g. 2 min 41 sec	e.g. 3 min
Target users	e.g. max 500 concurrent	Ramp up to 500
Total requests	e.g. 25,000	e.g. 180,077
Average response time	e.g. 11.44 s	e.g. 242 ms
Max response time	e.g. 21.15 s	e.g. 33.68 s
Throughput	e.g. 169.6 req/s	e.g. 857.45 req/s

Note: Values depend on the example test environment.

Conclusion

JMeter supports high concurrent user counts even at lower request throughput and is well suited for large-scale applications. k6 offers higher request throughput and is good for minimizing failed-request rates and for scenarios that require fast responses.

Which tool to use depends on your test requirements, target metrics, and application design. Both tools can be used in different scenarios and provide valuable data for performance testing. You can run your own load tests with these tools to evaluate your applications’ performance.