k6/http on Grafana Labs

asyncRequest( method, url, [body], [params] )

Mon, 21 Sep 2026 15:16:28 +0000

asyncRequest( method, url, [body], [params] )

Parameter	Type	Description
method	string	Request method (e.g. `'POST'`). Must be uppercase.
url	string / HTTP URL	Request URL (e.g. `'http://example.com'`).
body (optional)	string / object / ArrayBuffer	Request body. Objects will be `x-www-form-urlencoded` encoded.
params (optional)	object	Params object containing additional request parameters.

Returns

Type	Description
Promise with Response	HTTP Response object.

Note
When you enable the experimental async-metric-context feature flag, Promise reactions created by await or .then() keep the metric context active when you register them. If you call asyncRequest() from an async group, its HTTP metrics and metrics emitted after await keep the group’s tags and metadata.

Examples

Using http.asyncRequest() to issue a POST request:

import http from 'k6/http';

const url = 'https://quickpizza.grafana.com/api/post';

export default async function () {
  const data = { name: 'Bert' };

  // Using a JSON string as body
  const res = await http.asyncRequest('POST', url, JSON.stringify(data), {
    headers: { 'Content-Type': 'application/json' },
  });
  console.log(res.json().name); // Bert

  // Using an object as body, the headers will automatically include
  // 'Content-Type: application/x-www-form-urlencoded'.
  await http.asyncRequest('POST', url, data);
}

Using http.asyncRequest() to issue multiple requests, then Promise.race to determine which requests finish first:

import http from 'k6/http';

export default async () => {
  const urlOne = `https://quickpizza.grafana.com/api/delay/${randomInt(1, 5)}`;
  const urlTwo = `https://quickpizza.grafana.com/api/delay/${randomInt(1, 5)}`;
  const urlThree = `https://quickpizza.grafana.com/api/delay/${randomInt(1, 5)}`;

  const one = http.asyncRequest('GET', urlOne);
  const two = http.asyncRequest('GET', urlTwo);
  const three = http.asyncRequest('GET', urlThree);

  console.log('Racing:');
  console.log(urlOne);
  console.log(urlTwo);
  console.log(urlThree);

  const res = await Promise.race([one, two, three]);
  console.log('winner is', res.url, 'with duration of', res.timings.duration + 'ms');
};

function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min) + min);
}

Note
http.asyncRequest has no current way to abort a request.

In the preceding script, after res gets the value from the fastest request, the other requests will continue to execute. This might block the end of the iteration, because the iteration only stops once all async jobs finish.

batch( requests )

Mon, 21 Sep 2026 15:16:28 +0000

batch( requests )

Batch multiple HTTP requests together to issue them in parallel over multiple TCP connections. To set batch size, use the batch per host option.

Parameter	Type	Description
requests	array \| object	An array or object containing requests, in string or object form

Request definition

You have multiple ways to structure batch requests:

In an array of arrays
As an object or array of objects
As an array of URL strings

Defining batch requests as URL strings is a shortcut for GET requests. You can use this GET shortcut in objects—name a key and give it a URL value (refer to subsequent sections for example syntax).

Array and Object

You can define a request specified as an array or object with the following parameters.

Caution
When you define requests as an array, you must use a specific order of items. Note the Position column for the correct order.

Array position	Name	Type	Description
1	method	string	Mandatory. The HTTP method of the request. One of GET, POST, PUT, PATCH, DELETE, HEAD or OPTION.
2	url	string / HTTP URL	Mandatory. The URL to request.
3	body (optional)	string / object / ArrayBuffer	The body of the request if relevant. Can be set to `null` if not applicable but you want to set the last `params` argument.
4	params (optional)	object	Params like auth, custom headers and tags.

String

If you pass an array of string values, k6 automatically parses them into a batch of GET requests, where the target is the value of the strings.

Returns

Type	Description
object	The returned object contains Response objects. It is an array when users pass an array as `requests`, and is an ordinary object with string keys when named requests are used (see below).

Example with arrays

This example batches three URLs in arrays for parallel fetching:

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

export default function () {
  const responses = http.batch([
    ['GET', 'https://test.k6.io', null, { tags: { ctype: 'html' } }],
    ['GET', 'https://test.k6.io/style.css', null, { tags: { ctype: 'css' } }],
    ['GET', 'https://test.k6.io/images/logo.png', null, { tags: { ctype: 'images' } }],
  ]);
  check(responses[0], {
    'main page status was 200': (res) => res.status === 200,
  });
}

Example with request objects

This example uses objects to define a batch of POST requests (along with custom HTTP headers in a Params object to the request):

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

export default function () {
  const req1 = {
    method: 'GET',
    url: 'https://quickpizza.grafana.com/api/get',
  };
  const req2 = {
    method: 'DELETE',
    url: 'https://quickpizza.grafana.com/api/delete',
  };
  const req3 = {
    method: 'POST',
    url: 'https://quickpizza.grafana.com/api/post',
    body: JSON.stringify({ hello: 'world!' }),
    params: {
      headers: { 'Content-Type': 'application/json' },
    },
  };
  const responses = http.batch([req1, req2, req3]);
  // QuickPizza should return our POST data in the response body, so
  // we check the third response object to see that the POST worked.
  check(responses[2], {
    'form data OK': (res) => JSON.parse(res.body)['hello'] == 'world!',
  });
}

Note
In the preceding example, req1 can happen before req2 or req3.

Example with array of strings

This example uses an array of URL strings to send a batch of GET requests.

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

export default function () {
  const responses = http.batch(['http://test.k6.io', 'http://test.k6.io/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',
  });
}

Example object with named properties

Finally, you can also send in named requests by using an object instead of an array as the parameter to http.batch(). This example mixes string URLs and request objects.

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

export default function () {
  const requests = {
    'front page': 'https://k6.io',
    'features page': {
      method: 'GET',
      url: 'https://k6.io/features',
      params: { headers: { 'User-Agent': 'k6' } },
    },
  };
  const responses = http.batch(requests);
  // when accessing results, we use the name of the request as index
  // in order to find the corresponding Response object
  check(responses['front page'], {
    'front page status was 200': (res) => res.status === 200,
  });
}

cookieJar()

Mon, 21 Sep 2026 15:16:28 +0000

cookieJar()

Get the active cookie jar.

Type	Description
CookieJar	A CookieJar object.

Example

import http from 'k6/http';

export default function () {
  const jar = http.cookieJar();
}

del( url, [body], [params] )

Mon, 21 Sep 2026 15:16:28 +0000

del( url, [body], [params] )

Make a DELETE request.

Parameter	Type	Description
url	string / HTTP URL	Request URL (e.g. `http://example.com`).
body (optional, discouraged)	string / object / ArrayBuffer	Request body; objects will be `x-www-form-urlencoded`. This is discouraged, because sending a DELETE request with a body has no defined semantics and may cause some servers to reject it.
params (optional)	object	Params object containing additional request parameters.

Returns

Type	Description
Response	HTTP Response object.

Example

import http from 'k6/http';

const url = 'https://quickpizza.grafana.com/api/delete';

export default function () {
  const params = { headers: { 'X-MyHeader': 'k6test' } };
  http.del(url, null, params);
}

file( data, [filename], [contentType] )

Mon, 21 Sep 2026 15:16:28 +0000

file( data, [filename], [contentType] )

Create a file object that is used for building Multipart requests (file uploads).

Parameter	Type	Description
data	string / Array / ArrayBuffer	File data as string, array of numbers, or an `ArrayBuffer` object.
filename	string	The filename to specify for this field (or “part”) of the multipart request.
contentType	string	The content type to specify for this field (or “part”) of the multipart request.

Returns

Type	Description
FileData	A FileData object.

Example

import { sleep } from 'k6';
import { md5 } from 'k6/crypto';
import http from 'k6/http';

const binFile = open('/path/to/file.bin', 'b');

export default function () {
  const f = http.file(binFile, 'test.bin');
  console.log(md5(f.data, 'hex'));
  console.log(f.filename);
  console.log(f.content_type);
}

get( url, [params] )

Mon, 21 Sep 2026 15:16:28 +0000

get( url, [params] )

Make a GET request.

Parameter	Type	Description
url	string / HTTP URL	Request URL (e.g. `http://example.com`).
params (optional)	object	Params object containing additional request parameters.

Returns

Type	Description
Response	HTTP Response object.

Example fetching a URL

import http from 'k6/http';

export default function () {
  const res = http.get('https://test.k6.io');
  console.log(JSON.stringify(res.headers));
}

head( url, [params] )

Mon, 21 Sep 2026 15:16:28 +0000

head( url, [params] )

Make a HEAD request.

Parameter	Type	Description
url	string / HTTP URL	Request URL (e.g. `http://example.com`).
params (optional)	object	Params object containing additional request parameters.

Returns

Type	Description
Response	HTTP Response object.

Example fetching a URL

import http from 'k6/http';

export default function () {
  const res = http.head('https://test.k6.io');
  console.log(JSON.stringify(res.headers));
}

options( url, [body], [params] )

Mon, 21 Sep 2026 15:16:28 +0000

options( url, [body], [params] )

Parameter	Type	Description
url	string / HTTP URL	Request URL (e.g. `http://example.com`).
body (optional)	string / object / ArrayBuffer	Request body; objects will be `x-www-form-urlencoded`.
params (optional)	object	Params object containing additional request parameters.

Returns

Type	Description
Response	HTTP Response object.

Example

import http from 'k6/http';

const url = 'https://quickpizza.grafana.com/';

export default function () {
  const params = { headers: { 'X-MyHeader': 'k6test' } };
  const res = http.options(url, null, params);
  console.log(res.headers['Allow']);
}

patch( url, [body], [params] )

Mon, 21 Sep 2026 15:16:28 +0000

patch( url, [body], [params] )

Parameter	Type	Description
url	string / HTTP URL	Request URL (e.g. `http://example.com`).
body (optional)	string / object / ArrayBuffer	Request body; objects will be `x-www-form-urlencoded`.
params (optional)	object	Params object containing additional request parameters

Returns

Type	Description
Response	HTTP Response object.

Example

import http from 'k6/http';

const url = 'https://quickpizza.grafana.com/api/patch';

export default function () {
  const headers = { 'Content-Type': 'application/json' };
  const data = { name: 'Bert' };

  const res = http.patch(url, JSON.stringify(data), { headers: headers });

  console.log(JSON.parse(res.body).name);
}

post( url, [body], [params] )

Mon, 21 Sep 2026 15:16:28 +0000

post( url, [body], [params] )

Parameter	Type	Description
`url`	string / HTTP URL	Request URL (e.g. `http://example.com`).
`body`	string / object / ArrayBuffer	Request body; objects will be `x-www-form-urlencoded`.
`params` (optional)	object	Params object containing additional request parameters

For object bodies without file uploads, refer to the form encoding rules.

Returns

Type	Description
`Response`	HTTP Response object.

Example

import http from 'k6/http';

const url = 'https://quickpizza.grafana.com/api/json';
const logoBin = open('./logo.png', 'b');

export default function () {
  let data = { name: 'Bert' };

  // Using a JSON string as body
  let res = http.post(url, JSON.stringify(data), {
    headers: { 'Content-Type': 'application/json' },
  });
  console.log(res.json().json.name); // Bert

  // Using an object as body, the headers will automatically include
  // 'Content-Type: application/x-www-form-urlencoded'.
  res = http.post(url, data);
  console.log(res.json().form.name); // Bert

  // Using a binary array as body. Make sure to open() the file as binary
  // (with the 'b' argument).
  http.post(url, logoBin, { headers: { 'Content-Type': 'image/png' } });

  // Using an ArrayBuffer as body. Make sure to pass the underlying ArrayBuffer
  // instance to http.post(), and not the TypedArray view.
  data = new Uint8Array([104, 101, 108, 108, 111]);
  http.post(url, data.buffer, { headers: { 'Content-Type': 'image/png' } });
}

put( url, [body], [params] )

Mon, 21 Sep 2026 15:16:28 +0000

put( url, [body], [params] )

Parameter	Type	Description
url	string / HTTP URL	Request URL (e.g. `http://example.com`).
body (optional)	string / object / ArrayBuffer	Request body; objects will be `x-www-form-urlencoded`.
params (optional)	object	Params object containing additional request parameters.

Returns

Type	Description
Response	HTTP Response object.

Example

import http from 'k6/http';

const url = 'https://quickpizza.grafana.com/api/put';

export default function () {
  const headers = { 'Content-Type': 'application/json' };
  const data = { name: 'Bert' };

  const res = http.put(url, JSON.stringify(data), { headers: headers });

  console.log(JSON.parse(res.body).name);
}

request( method, url, [body], [params] )

Mon, 21 Sep 2026 15:16:28 +0000

request( method, url, [body], [params] )

Parameter	Type	Description
method	string	Request method (e.g. `'POST'`). Must be uppercase.
url	string / HTTP URL	Request URL (e.g. `'http://example.com'`).
body (optional)	string / object / ArrayBuffer	Request body; Objects will be `x-www-form-urlencoded` encoded.
params (optional)	object	Params object containing additional request parameters.

Form-encoded request bodies

When you pass a JavaScript object as the body without file uploads, k6 encodes it as application/x-www-form-urlencoded:

null and undefined become empty values, such as name=. The field remains in the request.
Arrays produce repeated keys, such as tag=one&tag=two.
Nested objects and nested arrays become empty values and cause k6 to log a warning. This also applies to objects inside arrays.

For example, { name: null, tags: ['one', null] } becomes name=&tags=one&tags=. To preserve nested data, serialize the body with JSON.stringify() and set the Content-Type header to application/json. Setting the header alone does not convert an object body to JSON.

These rules also apply to methods such as post().

Returns

Type	Description
Response	HTTP Response object.

Example

Using http.request() to issue a POST request:

import http from 'k6/http';

const url = 'https://quickpizza.grafana.com/api/post';

export default function () {
  const data = { name: 'Bert' };

  // Using a JSON string as body
  let res = http.request('POST', url, JSON.stringify(data), {
    headers: { 'Content-Type': 'application/json' },
  });
  console.log(res.json().name); // Bert

  // Using an object as body, the headers will automatically include
  // 'Content-Type: application/x-www-form-urlencoded'.
  res = http.request('POST', url, data);
  console.log(res.body); // name=Bert
}

setResponseCallback( callback )

Mon, 21 Sep 2026 15:16:28 +0000

setResponseCallback( callback )

Set the response callback to be called to determine if a response was expected/successful or not.

The result of this is that requests will be tagged with expected_response "true" or "false" and http_req_failed will be emitted with the reverse. This does include all redirects so if for a request only 200 is the expected response and there is 301 redirect before that, the redirect will be marked as failed as only status code 200 was marked as expected.

Exceptions

Due to implementation specifics:

Requests with authentication digest are always expected to first get 401 and then to get whatever was specified.
Requests with authentication ntlm will let a 401 status code on the first request as well as anything defined by expectedStatuses

Parameter	Type	Description
callback	expectedStatuses	an object returned from expectedStatuses

Currently only the very special expectedStatuses objects are supported but in the future it is planned that a JavaScript callback will be supported as well. By default requests with status codes between 200 and 399 are considered “expected”.

Setting the callback to null disables the tagging with expected_response and the emitting of http_req_failed.

It is recommended that if a per request responseCallback is used with Params it is actually defined once and used instead of creating it on each request.

Example

import http from 'k6/http';

http.setResponseCallback(http.expectedStatuses({ min: 200, max: 300 }));

const only300Callback = http.expectedStatuses(300);

export default () => {
  // this will use the default response callback and be marked as successful
  http.get('https://quickpizza.grafana.com/api/status/200');

  // this will be marked as a failed request as it won't get the expected status code of 300
  http.get('https://quickpizza.grafana.com/api/status/200', {
    responseCallback: only300Callback,
  });

  http.setResponseCallback(http.expectedStatuses(301));
  // from here on for this VU only the 301 status code will be successful so on the next iteration of
  // the VU the first request will be marked as failure
};

url\`url\`

Mon, 21 Sep 2026 15:16:28 +0000

url`url`

URLs that contain dynamic parts can introduce a large number of unique URLs in the metrics stream. You can use http.url to set a consistent name tag in your requests to remedy this issue. Read more on URL Grouping.

Parameter	Type	Description
url	template literal	Request URL (e.g. `http://example.com`).

Returns

Type	Description
HTTP URL	HTTP URL object.

Example

import http from 'k6/http';

export default function () {
  for (let id = 1; id <= 100; id++) {
    // tags.name="https://test.k6.io?id=${}",
    http.get(http.url`https://test.k6.io?id=${id}`);
  }
}

expectedStatuses( statuses )

Mon, 21 Sep 2026 15:16:28 +0000

expectedStatuses( statuses )

Returns a callback to be used with setResponseCallback to mark responses as expected based only on their status codes.

Parameter	Type	Description
statuses	integer/objects	either an integer or an object like {min:100, max:300} which gives a minimum and maximum expected status codes

You can have as many arguments as wanted in any order.

Example

import http from 'k6/http';

// setting some pretty strange status codes as expected
http.setResponseCallback(
  http.expectedStatuses(406, 500, { min: 200, max: 204 }, 302, { min: 305, max: 405 })
);

export default () => {
  // this one will actually be marked as failed as it doesn't match any of the above listed status
  // codes
  http.get('https://quickpizza.grafana.com/api/status/205');
};

CookieJar

Mon, 21 Sep 2026 15:16:28 +0000

CookieJar

CookieJar is an object for storing cookies that are set by the server, added by the client, or both. As described in the how-to guide on using Cookies, k6 handles cookies automatically by default. If you need more control over cookies you can however create your own cookie jar and select it as the active jar (instead of the default one created by k6) for one or more requests.

Method	Description
cookiesForURL(url)	Get Object of cookies where the key is the cookie name and the value is an array.
set(url, name, value, [options])	Set a cookie in the jar by specifying name, value and some other optional settings like domain, path etc.
clear(url)	Delete all cookies for the given URL.
delete(url, name)	Deletes the `name` cookie for the given URL.

Example

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

export default function () {
  const res1 = http.post('https://quickpizza.grafana.com/api/cookies?my_cookie=hello%20world', {
    redirects: 0,
  });
  const jar = http.cookieJar();
  const cookies = jar.cookiesForURL('https://quickpizza.grafana.com/api/cookies');
  check(res1, {
    "has cookie 'my_cookie'": (r) => cookies.my_cookie.length > 0,
    'cookie has correct value': (r) => cookies.my_cookie[0] === 'hello world',
  });

  jar.clear('https://quickpizza.grafana.com/api/cookies');

  const res2 = http.get('https://quickpizza.grafana.com/api/cookies');
  check(res2, {
    'has status 200': (r) => r.status === 200,
    "hasn't cookie 'my_cookie'": (r) => r.json().cookies.my_cookie == null,
  });
}

FileData

Mon, 21 Sep 2026 15:16:28 +0000

FileData

FileData is an object for wrapping data representing a file when doing multipart requests (file uploads). You create it by calling http.file( data, [filename], [contentType] ).

Name	Type	Description
FileData.data	string / Array / ArrayBuffer	File data as string, array of numbers, or an `ArrayBuffer` object.
FileData.content_type	string	The content type that will be specified in the multipart request.
FileData.filename	string	The filename that will be specified in the multipart request.

Example

import { sleep } from 'k6';
import { md5 } from 'k6/crypto';
import http from 'k6/http';

const binFile = open('/path/to/file.bin', 'b');

export default function () {
  const f = http.file(binFile, 'test.bin');
  console.log(md5(f.data, 'hex'));
  console.log(f.filename);
  console.log(f.content_type);
}

Params

Mon, 21 Sep 2026 15:16:28 +0000

Params

Params is an object used by the http.* methods that generate HTTP requests. Params contains request-specific options like e.g. HTTP headers that should be inserted into the request.

Name	Type	Description
`Params.auth`	string	The authentication method used for the request. It supports `digest` and `ntlm` authentication methods. Setting it to `basic` has no effect: k6 applies basic authentication automatically when the request URL contains credentials, such as `http://user:password@example.com`.
`Params.cookies`	object	Object with key-value pairs representing request scoped cookies (they won’t be added to VU cookie jar) `{cookies: { key: "val", key2: "val2" }}` You also have the option to say that a request scoped cookie should override a cookie in the VU cookie jar: `{cookies: { key: { value: "val", replace: true }}}`
`Params.headers`	object	Object with key-value pairs representing custom HTTP headers the user would like to add to the request.
`Params.jar`	object	http.CookieJar object to override default VU cookie jar with. Cookies added to request will be sourced from this jar and cookies set by server will be added to this jar.
`Params.redirects`	number	The number of redirects to follow for this request. Overrides the global test option `maxRedirects`.
`Params.tags`	object	Key-value pairs where the keys are names of tags and the values are tag values. Response time metrics generated as a result of the request will have these tags added to them, allowing the user to filter out those results specifically, when looking at results data.
`Params.timeout`	string / number	Maximum time to wait for the request to complete. Default timeout is 60 seconds (`"60s"`). The type can also be a number, in which case k6 interprets it as milliseconds, e.g., `60000` is equivalent to `"60s"`.
`Params.compression`	string	Sets whether the request body should be compressed. If set to `gzip` it will use gzip to compress the body and set the appropriate `Content-Length` and `Content-Encoding` headers. Possible values: `gzip`, `deflate`, `br`, `zstd`, and any comma-separated combination of them (for stacked compression). The default is no compression.
`Params.responseType`	string	ResponseType is used to specify how to treat the body of the response. The three options are: - text: k6 will return it as a string. This might not be what you want in cases of binary data as the conversation to UTF-16 will probably break it. This is also the default if discardResponseBodies is set to false or not set at all. - `binary`: k6 will return an ArrayBuffer object - `none`: k6 will return null as the body. The whole body will be ignored. This is the default when discardResponseBodies is set to true.
`Params.responseCallback`	expectedStatuses	sets a responseCallback only for this request. For performance reasons it’s better to initialize it once and reference it for each time the same callback will need to be used.

Example of custom HTTP headers and tags

A k6 script that will make an HTTP request with a custom HTTP header and tag results data with a specific tag

import http from 'k6/http';

export default function () {
  const params = {
    cookies: { my_cookie: 'value' },
    headers: { 'X-MyHeader': 'k6test' },
    redirects: 5,
    tags: { k6test: 'yes' },
  };
  const res = http.get('https://k6.io', params);
}

Example using http.batch() with Params

Here is another example using http.batch() with a Params argument:

import http from 'k6/http';

const url1 = 'https://quickpizza.grafana.com/api/get';
const url2 = 'https://quickpizza.grafana.com/api/delete';
const apiToken = 'f232831bda15dd233c53b9c548732c0197619a3d3c451134d9abded7eb5bb195';
const requestHeaders = {
  'User-Agent': 'k6',
  'Authorization': 'Token ' + apiToken,
};

export default function () {
  const res = http.batch([
    { method: 'GET', url: url1, params: { headers: requestHeaders } },
    { method: 'GET', url: url2 },
  ]);
}

Example of overriding discardResponseBodies

import http from 'k6/http';

export const options = { discardResponseBodies: true };
export default function () {}
export function setup() {
  // Get 10 random bytes as an ArrayBuffer. Without the responseType the body
  // will be null.
  const response = http.get('https://quickpizza.grafana.com/api/bytes/10', {
    responseType: 'binary',
  });
  // response.body is an ArrayBuffer, so wrap it in a typed array view to access
  // its elements.
  const bodyView = new Uint8Array(response.body);
  // This will output something like `176,61,15,66,233,98,223,196,43,1`
  console.log(bodyView);
}

Response

Mon, 21 Sep 2026 15:16:28 +0000

Response

Response is used by the http.* methods that generate HTTP request. Those methods return one (or more, in the case of http.batch()) Response objects that contain HTTP response contents and performance timing measurements.

Note that in the case of redirects, all the information in the Response object will pertain to the last request (the one that doesn’t get redirected).

Name	Type	Description
`Response.body`	string	Response body content, often used to extract dynamic data (see examples here) and when verifying the presence of content using checks. See Params.responseType and options.discardResponseBodies for how to discard the body when it is not needed (and to save memory) or when handling bodies with binary data.
`Response.cookies`	object	Response cookies. The object properties are the cookie names and the value is an array of cookie objects (with `name`, `value`, `domain`, `path`, `httpOnly`, `secure`, `maxAge` and `expires` fields).
`Response.error`	string	Error message if there was a non-HTTP error while trying to send the request.
`Response.error_code`	number	Error code if there was a non-HTTP error or 4xx or 5xx HTTP error it will be set to a specific code that describes the error. (Added in 0.24.0)
`Response.headers`	object	Key-value pairs representing all HTTP headers sent by the server. Note that the header names are in canonical form; for example, if the server responds with “accept-encoding”, the key will be “Accept-Encoding”. When requesting a header by a specific name, an array of strings is returned since the header can have multiple values. You can access each value by its index - for the first value, or for single-valued header, that will be `Response.headers["my_key"][0]`.
`Response.ocsp.produced_at`	number	If a stapled OSCP response was provided by server, the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC, representing the time when this OCSP stapled response was signed by CA (or by CA entrusted OCSP responder)
`Response.ocsp.this_update`	number	If a stapled OSCP response was provided by server, the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC, representing the time at which the status being indicated was known to be correct.
`Response.ocsp.next_update`	number	If a stapled OSCP response was provided by server, the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC, representing the time when this OCSP stapled response will be refreshed with CA (or by CA entrusted OCSP responder).
`Response.ocsp.revocation_reason`	string	The reason for revocation of the certificate (if that is the status), one of the following constants: `http.OCSP_REASON_UNSPECIFIED`, `http.OCSP_REASON_KEY_COMPROMISE`, `http.OCSP_REASON_CA_COMPROMISE`, `http.OCSP_REASON_AFFILIATION_CHANGED`, `http.OCSP_REASON_SUPERSEDED`, `http.OCSP_REASON_CESSATION_OF_OPERATION`, `http.OCSP_REASON_CERTIFICATE_HOLD`, `http.OCSP_REASON_REMOVE_FROM_CRL`, `http.OCSP_REASON_PRIVILEGE_WITHDRAWN` or `http.OCSP_REASON_AA_COMPROMISE`.
`Response.ocsp.revoked_at`	number	If a stapled OSCP response was provided by server, the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC, representing the time when this certificate was revoked (if that is the status).
`Response.ocsp.status`	string	The status of the certificate, one of the following constants: `http.OCSP_STATUS_GOOD`, `http.OCSP_STATUS_REVOKED`, `http.OCSP_STATUS_UNKNOWN` or `http.OCSP_STATUS_SERVER_FAILED`.
`Response.proto`	string	Protocol used to perform the transfer. Possible values are “HTTP/1.0”, “HTTP/1.1”, or “HTTP/2.0”.
`Response.remote_ip`	string	The IP address of the server handling the request.
`Response.remote_port`	number	The port that was connected to on the server side.
`Response.request.body`	string	Request body content.
`Response.request.cookies`	object	Request cookies. The object properties are the cookie names and the value is an array of cookie objects (with `name`, `value` and `replace` fields).
`Response.request.headers`	object	Request headers.
`Response.request.method`	string	Request HTTP method.
`Response.request.url`	string	Request URL.
`Response.status`	number	HTTP status code returned by the server.
`Response.status_text`	string	(new in k6 v0.29.0) HTTP status text returned by the server.
`Response.timings`	object	Performance timing information for the HTTP request.
`Response.timings.blocked`	float	Containing time (ms) spent blocked before initiating request.
`Response.timings.connecting`	float	Containing time (ms) spent setting up TCP connection to host.
`Response.timings.tls_handshaking`	float	Containing time (ms) spent handshaking TLS session with host.
`Response.timings.sending`	float	Containing time (ms) spent sending request.
`Response.timings.waiting`	float	Containing time (ms) spent waiting for server response.
`Response.timings.receiving`	float	Containing time (ms) spent receiving response data.
`Response.timings.duration`	float	Total time for the request (ms). It’s equal to `sending + waiting + receiving`, i.e. how long did the remote server take to process the request and respond, without the initial DNS lookup/connection times.
`Response.tls_cipher_suite`	string	If a TLS session was established, the cipher suite that was used.
`Response.tls_version`	string	If a TLS session was established, the version of SSL/TLS that was used.
`Response.url`	string	The URL that was ultimately fetched (i.e. after any potential redirects).
Response.clickLink( [params] )	function	Parses response as HTML, looks for a specific link and does the request-level equivalent of a click on that link.
Response.html()	function	Returns an object that supports Selection.find(selector).
Response.json( [selector] )	function	Parses the response body data as JSON and returns a JS object or array. This call caches the deserialized JSON data, additional calls will return the cached data. An optional selector can be specified to extract a specific part of the data, see here for selector syntax.
Response.submitForm( [params] )	function	Parses response as HTML, parses the specified form (defaults to looking for a “form” element) with option to override fields and then submits form taking form’s `method` and `action` into account.

Example

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

export default function () {
  const res = http.get('https://k6.io');
  for (const p in res.headers) {
    if (res.headers.hasOwnProperty(p)) {
      console.log(p + ' : ' + res.headers[p]);
    }
  }
  check(res, {
    'status is 200': (r) => r.status === 200,
    'caption is correct': (r) => r.html('h1').text() == 'Example Domain',
  });
}

A k6 script that will make an HTTP request and print all HTTP response headers