A comprehensive guide to your development sandbox.

1. 1.Open an endpoint response variant.
2. 2.Put tokens directly inside the JSON response body or header values.
3. 3.Send a request with matching params, query, headers, or body fields.
4. 4.Mocklify replaces each token before returning the response.

{
  "id": "{{params.userId}}",
  "name": "{{request.body.name}}",
  "source": "{{query.source}}",
  "tenant": "{{headers.x-tenant}}",
  "plan": "{{env.PLAN_NAME}}",
  "request": {
    "path": "{{request.path}}",
    "receivedAt": "{{now}}"
  },
  "flags": {
    "beta": "{{bool:query.beta}}",
    "score": "{{number:request.body.score}}"
  }
}

Typed tokens such as {{number:request.body.score}} and {{bool:query.beta}} are useful when the output must stay valid JSON numbers or booleans.

1. 1.Create or edit a webhook.
2. 2.Add tokens to the URL template, headers JSON, query JSON, or body template.
3. 3.Bind the webhook to the endpoint that should trigger it.
4. 4.When that endpoint is called, Mocklify renders the webhook request and sends it downstream.

URL
https://hooks.example.com/mocklify/{{project.slug}}/{{environment.slug}}

Headers template
{
  "Content-Type": "application/json",
  "X-Tenant": "{{headers.x-tenant}}",
  "X-Request-Source": "{{query.source}}"
}

Query template
{
  "userId": "{{params.userId}}",
  "trace": "{{request.path}}"
}

Body template
{
  "event": "user.updated",
  "name": "{{request.body.name}}",
  "requestPayload": "{{json:request.body}}",
  "responseStatus": "{{number:response.status}}",
  "responsePayload": "{{json:response.body}}"
}

Use {{json:request.body}} for the incoming request body and {{json:response.body}} for the rendered mock response body.

1. 1.Create a non-default response variant.
2. 2.Choose the section to inspect: params, query, headers, or body.
3. 3.Set the key to the incoming field name, such as source, x-tenant, or user.role.
4. 4.Set the value to a literal or a rendered template; the variant wins only when the rule passes.

{
  "query": {
    "type": "group",
    "combinator": "AND",
    "children": [
      { "type": "condition", "key": "source", "op": "=", "value": "mobile" },
      { "type": "condition", "key": "tier", "op": "=", "value": "{{request.body.plan}}" }
    ]
  },
  "headers": {
    "type": "group",
    "children": [
      { "type": "condition", "key": "x-tenant", "op": "=", "value": "{{request.body.tenant}}" }
    ]
  },
  "body": {
    "type": "group",
    "children": [
      { "type": "condition", "key": "user.name", "op": "contains", "value": "{{query.name}}" },
      { "type": "condition", "key": "score", "op": ">=", "value": "80" }
    ]
  }
}

Keys are literal field paths such as user.name. Values may contain templates such as {{request.body.plan}} or {{query.name}}.

1. 1.Create a table with stable column keys, such as id, name, source, or updatedAt.
2. 2.Enable a table script on a response variant.
3. 3.Use tokens in where to find rows and values to write request data into rows.
4. 4.Return the script result from the response body with table tokens.

Table script
{
  "enabled": true,
  "table": "customers",
  "operation": "update",
  "where": {
    "id": "{{params.userId}}"
  },
  "values": {
    "name": "{{request.body.name}}",
    "source": "{{query.source}}",
    "updatedAt": "{{now}}"
  }
}

Response body
{
  "ok": true,
  "customer": "{{json:table.row}}",
  "changedRows": "{{number:table.count}}"
}

Use {{json:table.row}} for the first affected row, {{json:table.rows}} for all rows, and {{table.count}} for the result count.