HTTP Testing

Test HTTP/1.1 and HTTP/2 APIs with k6’s comprehensive HTTP module

k6 provides full support for HTTP/1.1 and HTTP/2 protocols, enabling you to test REST APIs, web services, and HTTP endpoints with a rich set of methods and configuration options.

HTTP Methods

k6 supports all standard HTTP methods through the k6/http module.

Simple GET Request

import http from 'k6/http';

export default function () {
  http.get('https://quickpizza.grafana.com');
}

HTTP/2 Support

k6 automatically handles HTTP/2 connections when the server supports it. You can verify the protocol version in your tests.

import http from "k6/http";
import { check } from "k6";

export default function () {
  check(http.get("https://quickpizza.grafana.com"), {
    "status is 200": (r) => r.status == 200,
    "protocol is HTTP/2": (r) => r.proto == "HTTP/2.0",
  });
}

Authentication

Basic Auth

k6 supports HTTP Basic Authentication through URL credentials or custom headers.

import encoding from "k6/encoding";
import http from "k6/http";
import { check } from "k6";

export default function() {
  // Method 1: Username and password in URL
  let res = http.get("http://user:[e-mail]/basic-auth/user/passwd");

  check(res, {
    "status is 200": (r) => r.status === 200,
    "is authenticated": (r) => r.json().authenticated === true,
    "is correct user": (r) => r.json().user === "user"
  });

  // Method 2: Authorization header
  res = http.get(
    "http://httpbin.org/basic-auth/user/passwd",
    {
      headers: {
        "Authorization": "Basic " + encoding.b64encode("user:passwd")
      }
    }
  );

  check(res, {
    "status is 200": (r) => r.status === 200,
    "is authenticated": (r) => r.json().authenticated === true,
  });
}

Bearer Token

import http from "k6/http";

export default function() {
  const token = "your-api-token";
  const params = {
    headers: {
      "Authorization": `Bearer ${token}`,
    },
  };

  http.get("https://api.example.com/data", params);
}

Batch Requests

Perform multiple HTTP requests in parallel for improved performance.

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

export default function() {
  const responses = http.batch([
    "https://quickpizza.grafana.com/test.k6.io",
    "https://quickpizza.grafana.com/pi.php"
  ]);

  check(responses[0], {
    "main page 200": res => res.status === 200,
  });

  check(responses[1], {
    "pi page 200": res => res.status === 200,
    "pi page has right content": res => res.body === "3.14",
  });
}

Batch requests are executed in parallel and wait for all requests to complete before continuing.

Request Parameters

Configure HTTP requests with various parameters:

import http from "k6/http";

export default function() {
  const params = {
    headers: {
      "Content-Type": "application/json",
      "X-Custom-Header": "value",
    },
    tags: {
      name: "MyRequest",
    },
    timeout: "60s",
    redirects: 5,
    cookies: {
      session: "session-id-value",
    },
  };

  http.post(
    "https://api.example.com/endpoint",
    JSON.stringify({ key: "value" }),
    params
  );
}

Response Object

HTTP responses provide comprehensive information about the request:

Property	Description
status	HTTP status code
status_text	HTTP status text
proto	Protocol version (e.g., “HTTP/1.1”, “HTTP/2.0”)
headers	Response headers as object
body	Response body as string
json()	Parse response body as JSON
cookies	Response cookies
timings	Request timing information
error	Error message (if request failed)
error_code	Error code (if request failed)

TLS Configuration

k6 provides constants for configuring TLS connections:

import http from "k6/http";

export const options = {
  tlsVersion: {
    min: http.TLS_1_2,
    max: http.TLS_1_3,
  },
};

export default function() {
  http.get("https://api.example.com");
}

Available TLS Constants

• http.TLS_1_0
• http.TLS_1_1
• http.TLS_1_2
• http.TLS_1_3

Cookie Management

Manage cookies across requests with cookie jars:

import http from "k6/http";

export default function() {
  // Cookies are automatically maintained across requests
  const jar = http.cookieJar();
  
  jar.set("https://example.com", "session", "value");
  
  http.get("https://example.com/authenticated");
}

Async Requests

k6 supports asynchronous HTTP requests using promises:

Async requests are an experimental feature and may not be suitable for all use cases.

import http from "k6/http";

export default async function() {
  const response = await http.asyncRequest(
    "GET",
    "https://api.example.com/data"
  );
  console.log(response.status);
}

Best Practices

1. Use batch requests for parallel operations to improve test efficiency
2. Set appropriate timeouts to prevent hanging requests
3. Verify protocol versions when testing HTTP/2 support
4. Use tags to organize and filter metrics
5. Check response status before parsing JSON to avoid errors
6. Reuse connections by making multiple requests in the same VU iteration

Related Resources

• HTTP API Reference
• Thresholds
• Checks