docs

Init context

open( filePath, [mode] )

k6

check( val, sets, [tags] )
fail( [err] )
group( name, fn )
randomSeed( int )
sleep( t )

k6/crypto

createHash( algorithm )
createHMAC( algorithm, secret )
hmac( algorithm, secret, data, outputEncoding )
md4( input, outputEncoding )
md5( input, outputEncoding )
randomBytes( int )
ripemd160( input, outputEncoding )
sha1( input, outputEncoding )
sha256( input, outputEncoding )
sha384( input, outputEncoding )
sha512( input, outputEncoding )
sha512_256( input, outputEncoding )
sha512_224( input, outputEncoding )
Hasher

k6/data

SharedArray

k6/encoding

b64decode( input, [encoding], [format] )
b64encode( input, [encoding] )

k6/execution

0

k6/html

parseHTML( src )
Element
Selection

k6/http

batch( requests )
cookieJar()
del( url, [body], [params] )
file( data, [filename], [contentType] )
get( url, [params] )
options( url, [body], [params] )
patch( url, [body], [params] )
post( url, [body], [params] )
put( url, [body], [params] )
request( method, url, [body], [params] )
setResponseCallback( callback )
url`url`
expectedStatuses( statuses )
CookieJar
FileData
Params
Response

k6/metrics

Counter
Gauge
Rate
Trend

k6/net/grpc

Client
Params
Response
Constants

k6/ws

connect( url, params, callback )
Params
Socket

Error Codes

0
k6.ioapp.k6.io

No results for “”

Powered byAlgolia
⚠️ This is archived documentation for v0.34. Go to the latest version

batch( requests )

suggest edits

Batch multiple HTTP requests together, to issue them in parallel over multiple TCP connections.

ParameterTypeDescription
requestsarray | objectAn array or object containing requests, in string or object form

When each request is specified as an array, the order of the arguments for each request is as follows:

PositionNameTypeDescription
1methodstringMandatory. The HTTP method of the request. One of GET, POST, PUT, PATCH, DELETE, HEAD or OPTION.
2urlstring / HTTP URLMandatory. The URL to request.
3body (optional)string / object / ArrayBufferThe body of the request if relevant. Can be set to null if not applicable but you want to set the last params argument.
4params (optional)objectParams like auth, custom headers and tags.

Returns

TypeDescription
objectThe 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 request as an array

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 batching three URLs 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

You can also use objects to hold information about a request. Here's an example where we do that to send a POST request, also using the Params object to give the request custom headers:

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


export default function () {
  const req1 = {
    method: 'GET',
    url: 'https://httpbin.test.k6.io/get',
  };
  const req2 = {
    method: 'GET',
    url: 'https://test.k6.io',
  };
  const req3 = {
    method: 'POST',
    url: 'https://httpbin.test.k6.io/post',
    body: {
      hello: 'world!',
    },
    params: {
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    },
  };
  const responses = http.batch([req1, req2, req3]);
  // httpbin.test.k6.io 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)['form']['hello'] == 'world!',
  });
}

Note that the requests in the example above may happen in any order, or simultaneously. When running requests in batches, there is no guarantee that e.g. req1 will happen before req2 or req3

Example with named requests

Finally, you can also send in named requests by using an object instead of an array as the parameter to http.batch(). In the following example we do this, and we also show that it is possible to mix 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
  // to find the corresponding Response object
  check(responses['front page'], {
    'front page status was 200': (res) => res.status === 200,
  });
}