Response Templating

Response headers and bodies, as well as proxy URLs, can optionally be rendered using Handlebars templates. This enables attributes of the request to be used in generating the response e.g. to pass the value of a request ID header as a response header or render an identifier from part of the URL in the response body.

Enabling response templating

When starting WireMock programmatically, response templating can be enabled by adding ResponseTemplateTransformer as an extension e.g.

public WireMockRule wm = new WireMockRule(options()
    .extensions(new ResponseTemplateTransformer(false))

The boolean constructor parameter indicates whether the extension should be applied globally. If true, all stub mapping responses will be rendered as templates prior to being served.

Otherwise the transformer will need to be specified on each stub mapping by its name response-template:




    "request": {
        "urlPath": "/templated"
    "response": {
        "body": "{{request.path.[0]}}",
        "transformers": ["response-template"]

Command line parameters can be used to enable templating when running WireMock standalone.

Template caching

By default, all templated fragments (headers, bodies and proxy URLs) are cached in their compiled form for performance, since compilation can be expensive for larger templates.

The size of the cache is not limited by default, but can be a construction time:

public WireMockRule wm = new WireMockRule(options()

Setting the limit to 0 will disable caching completely.


Templating also works when defining proxy URLs, e.g.




    "request": {
        "urlPath": "/templated"
    "response": {
        "proxyBaseUrl": "{{request.headers.X-WM-Proxy-Url}}",
        "transformers": ["response-template"]

Templated body file

The body file for a response can be selected dynamically by templating the file path:




  "request" : {
    "urlPathPattern" : "/static/.*",
    "method" : "GET"
  "response" : {
    "status" : 200,
    "bodyFileName" : "files/{{request.pathSegments.[1]}}"

The request model

The model of the request is supplied to the header and body templates. The following request attributes are available:

request.url - URL path and query

request.path - URL path

request.pathSegments.[<n>]- URL path segment (zero indexed) e.g. request.pathSegments.[2]

request.query.<key>- First value of a query parameter e.g.

request.query.<key>.[<n>]- nth value of a query parameter (zero indexed) e.g.[5]

request.method- request method e.g. POST hostname part of the URL e.g.

request.port- port number e.g. 8080

request.scheme- protocol part of the URL e.g. https

request.baseUrl- URL up to the start of the path e.g.

request.headers.<key>- First value of a request header e.g. request.headers.X-Request-Id

request.headers.[<key>]- Header with awkward characters e.g. request.headers.[$?blah]

request.headers.<key>.[<n>]- nth value of a header (zero indexed) e.g. request.headers.ManyThings.[1]

request.cookies.<key> - First value of a request cookie e.g. request.cookies.JSESSIONID

request.cookies.<key>.[<n>] - nth value of a request cookie e.g. request.cookies.JSESSIONID.[2]

request.body - Request body text (avoid for non-text bodies)

Values that can be one or many

A number of HTTP elements (query parameters, form fields, headers) can be single or multiple valued. The template request model and built-in helpers attempt to make this easy to work with by wrapping these in a “list or single” type that returns the first (and often only) value when no index is specified, but also support index access.

For instance, given a request URL like /multi-query?things=1&things=2&things=3 I can extract the query data in the following ways:

{{request.query.things}} // Will return 1
{{request.query.things.0}} // Will return 1
{{request.query.things.first}} // Will return 1
{{request.query.things.1}} // Will return 2
{{request.query.things.[-1]}} // Will return 2
{{request.query.things.last}} // Will return 3


When using the eq helper with one-or-many values, it is necessary to use the indexed form, even if only one value is present. The reason for this is that the non-indexed form returns the wrapper type and not a String, and will therefore fail any comparison with another String value.

Using transformer parameters

Parameter values can be passed to the transformer as shown below (or dynamically added to the parameters map programmatically in custom transformers).


      .withTransformerParameter("MyCustomParameter", "Parameter Value")));


    "request": {
        "urlPath": "/templated"
    "response": {
        "body": "{{request.path.[0]}}",
        "transformers": ["response-template"],
        "transformerParameters" : {
            "MyCustomParameter" : "Parameter Value"

These parameters can be referenced in template body content using the parameters. prefix:

<h1>The MyCustomParameter value is {{parameters.MyCustomParameter}}</h1>

Handlebars helpers

All of the standard helpers (template functions) provided by the Java Handlebars implementation by jknack plus all of the string helpers and the conditional helpers are available e.g.


Number and assignment helpers

Variable assignment and number helpers are available:

{{#assign 'myCapitalisedQuery'}}{{capitalize}}{{/assign}}

{{isOdd 3}}
{{isOdd 3 'rightBox'}}

{{isEven 2}}
{{isEven 4 'leftBox'}}

{{stripes 3 'row-even' 'row-odd'}}

XPath helpers

Addiionally some helpers are available for working with JSON and XML.

When the incoming request contains XML, the xPath helper can be used to extract values or sub documents via an XPath 1.0 expression. For instance, given the XML


The following will render “Stuff” into the output:

{{xPath request.body '/outer/inner/text()'}}

And given the same XML the following will render <inner>Stuff</inner>:

{{xPath request.body '/outer/inner'}}

As a convenience the soapXPath helper also exists for extracting values from SOAP bodies e.g. for the SOAP document:

<soap:Envelope xmlns:soap="">

The following will render “success” in the output:

{{soapXPath request.body '/a/test/text()'}}

Using the output of xPath in other helpers

Since version 2.27.0 the XPath helper returns collections of node objects rather than a single string, meaning that the result can be used in further helpers.

The returned node objects have the following properties:

name - the local XML element name.

text - the text content of the element.

attributes - a map of the element’s attributes (name: value)

Referring to the node itself will cause it to be printed.

A common use case for returned node objects is to iterate over the collection with the each helper:

{{#each (xPath request.body '/things/item') as |node|}}
  name: {{}}, text: {{node.text}}, ID attribute: {{}}

JSONPath helper

It is similarly possible to extract JSON values or sub documents via JSONPath using the jsonPath helper. Given the JSON

  "outer": {
    "inner": "Stuff"

The following will render “Stuff” into the output:

{{jsonPath request.body '$.outer.inner'}}

And for the same JSON the following will render { "inner": "Stuff" }:

{{jsonPath request.body '$.outer'}}

Date and time helpers

A helper is present to render the current date/time, with the ability to specify the format (via Java’s SimpleDateFormat) and offset.

{{now offset='3 days'}}
{{now offset='-24 seconds'}}
{{now offset='1 years'}}
{{now offset='10 years' format='yyyy-MM-dd'}}

Dates can be rendered in a specific timezone (the default is UTC):

{{now timezone='Australia/Sydney' format='yyyy-MM-dd HH:mm:ssZ'}}

Pass epoch as the format to render the date as UNIX epoch time (in milliseconds), or unix as the format to render the UNIX timestamp in seconds.

{{now offset='2 years' format='epoch'}}
{{now offset='2 years' format='unix'}}

Dates can be parsed from other model elements:

{{date (parseDate request.headers.MyDate) offset='-1 days'}}

Random value helper

Random strings of various kinds can be generated:

{{randomValue length=33 type='ALPHANUMERIC'}}
{{randomValue length=12 type='ALPHANUMERIC' uppercase=true}}
{{randomValue length=55 type='ALPHABETIC'}}
{{randomValue length=27 type='ALPHABETIC' uppercase=true}}
{{randomValue length=10 type='NUMERIC'}}
{{randomValue length=5 type='ALPHANUMERIC_AND_SYMBOLS'}}
{{randomValue type='UUID'}}

Pick random helper

A value can be randomly selected from a literal list:

{{{pickRandom '1' '2' '3'}}}

Or from a list passed as a parameter:

{{{pickRandom (jsonPath request.body '$.names')}}}

String trim helper

Use the trim helper to remove whitespace from the start and end of the input:

{{trim request.headers.X-Padded-Header}}

    Some stuff with whitespace

Base64 helper

The base64 helper can be used to base64 encode and decode values:

{{base64 request.headers.X-Plain-Header}}
{{base64 request.headers.X-Encoded-Header decode=true}}

Content to encode     

{{#base64 padding=false}}
Content to encode without padding    

{{#base64 decode=true}}

URL encoding helper

The urlEncode helper can be used to URL encode and decode values:

{{urlEncode request.headers.X-Plain-Header}}
{{urlEncode request.headers.X-Encoded-Header decode=true}}

Content to encode     

{{#urlEncode decode=true}}

Form helper

The formData helper parses its input as an HTTP form, returning an object containing the individual fields as attributes. The helper takes the input string and variable name as its required parameters, with an optional urlDecode parameter indicating that values should be URL decoded. The folowing example will parse the request body as a form, then output a single field formField3:

{{formData request.body 'form' urlDecode=true}}{{form.formField3}}

If the form submitted has multiple values for a given field, these can be accessed by index:

{{formData request.body 'form' urlDecode=true}}{{form.multiValueField.1}}, {{form.multiValueField.2}}
{{formData request.body 'form' urlDecode=true}}{{form.multiValueField.first}}, {{form.multiValueField.last}}

Regular expression extract helper

The regexExtract helper supports extraction of values matching a regular expresson from a string.

A single value can be extracted like this:

{{regexExtract request.body '[A-Z]+'}}"

Regex groups can be used to extract multiple parts into an object for later use (the last parameter is a variable name to which the object will be assigned):

{{regexExtract request.body '([a-z]+)-([A-Z]+)-([0-9]+)' 'parts'}}

Size helper

The size helper returns the size of a string, list or map:

{{size 'abcde'}}
{{size request.query.things}}

Hostname helper

The local machine’s hostname can be printed:


System property helper

Environment variables and system properties can be printed:

{{systemValue type='ENVIRONMENT' key='PATH'}}
{{systemValue type='PROPERTY' key='os.path'}}

To avoid disclosure of sensitive variables, only permitted variables can be read. Permitted variable names are defined via a set of regular expressions. These can be configured when constructing the response template extension:

public WireMockRule wm = new WireMockRule(options()
        .extensions(new ResponseTemplateTransformer.Builder()

The regular expressions are matched in a case-insensitive manner.

If no permitted system key patterns are set, a single default of wiremock.* will be used.

Custom helpers

Custom Handlebars helpers can be registered with the transformer on construction:

Helper<String> stringLengthHelper = new Helper<String>() {
    public Object apply(String context, Options options) throws IOException {
        return context.length();

public WireMockRule wm = new WireMockRule(
    options().extensions(new ResponseTemplateTransformer(false, "string-length", stringLengthHelper))