---
title: Create a test
description: This endpoint is deprecated. To create a test, use Create an API test, or Create a browser test.
breadcrumbs: Docs > API > Create a test
---

> For the complete documentation index, see [llms.txt](https://dnd37xeb23o8n.cloudfront.net/jen.gilbert/astro-base/llms.txt).

# Create a test

## v1 (deprecated)

| Datadog site      | API endpoint                                               |
| ----------------- | ---------------------------------------------------------- |
| app.datadoghq.com | POST https://api.datadoghq.com/api/v1/synthetics/tests     |
| us3.datadoghq.com | POST https://api.us3.datadoghq.com/api/v1/synthetics/tests |
| us5.datadoghq.com | POST https://api.us5.datadoghq.com/api/v1/synthetics/tests |
| app.datadoghq.eu  | POST https://api.datadoghq.eu/api/v1/synthetics/tests      |
| ap1.datadoghq.com | POST https://api.ap1.datadoghq.com/api/v1/synthetics/tests |
| ap2.datadoghq.com | POST https://api.ap2.datadoghq.com/api/v1/synthetics/tests |
| uk1.datadoghq.com | POST https://api.uk1.datadoghq.com/api/v1/synthetics/tests |
| app.ddog-gov.com  | POST https://api.ddog-gov.com/api/v1/synthetics/tests      |
| us2.ddog-gov.com  | POST https://api.us2.ddog-gov.com/api/v1/synthetics/tests  |

### Overview

This endpoint is deprecated. To create a test, use [Create an API test](https://docs.datadoghq.com/api/latest/synthetics.md#create-an-api-test), or [Create a browser test](https://docs.datadoghq.com/api/latest/synthetics.md#create-a-browser-test).

This endpoint requires the `synthetics_write` permission.

OAuth apps require the `synthetics_write` authorization [scope](https://dnd37xeb23o8n.cloudfront.net/jen.gilbert/astro-base/api/latest/scopes.md#synthetics) to access this endpoint.

### Request

#### Body Data (required)

Details of the test to create.

{% tabs %}
{% tab label="Model" %}
| Parent field         | Field                               | Type      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------- | ----------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|                      | config                              | object    | Configuration object for a Synthetic test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| config               | assertions                          | [<oneOf>] | Array of assertions used for the test. Required for single API tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| assertions           | Object 1                            | object    | An assertion which uses a simple target.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Object 1             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `contains`, `doesNotContain`, `is`, `isNot`, `lessThan`, `lessThanOrEqual`, `moreThan`, `moreThanOrEqual`, `matches`, `doesNotMatch`, `validates`, `isInMoreThan`, `isInLessThan`, `doesNotExist`, `isUndefined`.                                                                                                                                                                                                                                                                                          |
| Object 1             | property                            | string    | The associated assertion property.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 1             | target [*required*]                 | <oneOf>   | Value used by the operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| target               | Object 1                            | double    | Numeric value used by the operator in assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| target               | Object 2                            | string    | String value used by the operator in assertions. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Object 1             | timingsScope                        | enum      | Timings scope for response time assertions. Allowed enum values: `all`, `withoutDNS`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Object 1             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `body`, `header`, `statusCode`, `certificate`, `responseTime`, `property`, `recordEvery`, `recordSome`, `tlsVersion`, `minTlsVersion`, `latency`, `packetLossPercentage`, `packetsReceived`, `networkHop`, `receivedMessage`, `grpcHealthcheckStatus`, `grpcMetadata`, `grpcProto`, `connection`, `multiNetworkHop`, `jitter`, `mcpToolNameLength`, `mcpToolCount`.                                                                                                                                              |
| assertions           | Object 2                            | object    | An assertion which targets body hash.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Object 2             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `md5`, `sha1`, `sha256`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Object 2             | target [*required*]                 | <oneOf>   | Value used by the operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| target               | Object 1                            | double    | Numeric value used by the operator in assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| target               | Object 2                            | string    | String value used by the operator in assertions. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Object 2             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `bodyHash`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| assertions           | Object 3                            | object    | An assertion for the `validatesJSONPath` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 3             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `validatesJSONPath`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Object 3             | property                            | string    | The associated assertion property.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 3             | target                              | object    | Composed target for `validatesJSONPath` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| target               | elementsOperator                    | string    | The element from the list of results to assert on.  To choose from the first element in the list `firstElementMatches`, every element in the list `everyElementMatches`, at least one element in the list `atLeastOneElementMatches` or the serialized value of the list `serializationMatches`.                                                                                                                                                                                                                                                             |
| target               | jsonPath                            | string    | The JSON path to assert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| target               | operator                            | string    | The specific operator to use on the path.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| target               | targetValue                         | <oneOf>   | The path target value to compare to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| targetValue          | Object 1                            | double    | Numeric value used by the operator in assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| targetValue          | Object 2                            | string    | String value used by the operator in assertions. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Object 3             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `body`, `header`, `statusCode`, `certificate`, `responseTime`, `property`, `recordEvery`, `recordSome`, `tlsVersion`, `minTlsVersion`, `latency`, `packetLossPercentage`, `packetsReceived`, `networkHop`, `receivedMessage`, `grpcHealthcheckStatus`, `grpcMetadata`, `grpcProto`, `connection`, `multiNetworkHop`, `jitter`, `mcpToolNameLength`, `mcpToolCount`.                                                                                                                                              |
| assertions           | Object 4                            | object    | An assertion for the `validatesJSONSchema` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Object 4             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `validatesJSONSchema`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Object 4             | target                              | object    | Composed target for `validatesJSONSchema` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| target               | jsonSchema                          | string    | The JSON Schema to assert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| target               | metaSchema                          | enum      | The JSON Schema meta-schema version used in the assertion. Allowed enum values: `draft-07`, `draft-06`.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Object 4             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `body`, `header`, `statusCode`, `certificate`, `responseTime`, `property`, `recordEvery`, `recordSome`, `tlsVersion`, `minTlsVersion`, `latency`, `packetLossPercentage`, `packetsReceived`, `networkHop`, `receivedMessage`, `grpcHealthcheckStatus`, `grpcMetadata`, `grpcProto`, `connection`, `multiNetworkHop`, `jitter`, `mcpToolNameLength`, `mcpToolCount`.                                                                                                                                              |
| assertions           | Object 5                            | object    | An assertion for the `validatesXPath` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Object 5             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `validatesXPath`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Object 5             | property                            | string    | The associated assertion property.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 5             | target                              | object    | Composed target for `validatesXPath` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| target               | operator                            | string    | The specific operator to use on the path.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| target               | targetValue                         | <oneOf>   | The path target value to compare to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| targetValue          | Object 1                            | double    | Numeric value used by the operator in assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| targetValue          | Object 2                            | string    | String value used by the operator in assertions. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| target               | xPath                               | string    | The X path to assert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Object 5             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `body`, `header`, `statusCode`, `certificate`, `responseTime`, `property`, `recordEvery`, `recordSome`, `tlsVersion`, `minTlsVersion`, `latency`, `packetLossPercentage`, `packetsReceived`, `networkHop`, `receivedMessage`, `grpcHealthcheckStatus`, `grpcMetadata`, `grpcProto`, `connection`, `multiNetworkHop`, `jitter`, `mcpToolNameLength`, `mcpToolCount`.                                                                                                                                              |
| assertions           | Object 6                            | object    | A JavaScript assertion.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Object 6             | code [*required*]                   | string    | The JavaScript code that performs the assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Object 6             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `javascript`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| assertions           | Object 7                            | object    | An assertion that checks that an MCP server advertises the expected capabilities.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Object 7             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `contains`, `doesNotContain`, `is`, `isNot`, `lessThan`, `lessThanOrEqual`, `moreThan`, `moreThanOrEqual`, `matches`, `doesNotMatch`, `validates`, `isInMoreThan`, `isInLessThan`, `doesNotExist`, `isUndefined`.                                                                                                                                                                                                                                                                                          |
| Object 7             | target [*required*]                 | [string]  | List of MCP server capabilities to assert against.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 7             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `mcpServerCapabilities`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| assertions           | Object 8                            | object    | An assertion that verifies the MCP server response respects the MCP specification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 8             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `mcpRespectsSpecification`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| config               | configVariables                     | [object]  | Array of variables used for the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| configVariables      | example                             | string    | Example for the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| configVariables      | id                                  | string    | ID of the variable for global variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| configVariables      | name [*required*]                   | string    | Name of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| configVariables      | pattern                             | string    | Pattern of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| configVariables      | secure                              | boolean   | Whether the value of this variable will be obfuscated in test results. Only for config variables of type `text`.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| configVariables      | type [*required*]                   | enum      | Type of the configuration variable. Allowed enum values: `global`, `text`, `email`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| config               | request                             | object    | Object describing the Synthetic test request.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| request              | allow_insecure                      | boolean   | Allows loading insecure content for an HTTP request in a multistep test step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| request              | basicAuth                           | <oneOf>   | Object to handle basic authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| basicAuth            | <type=web>                          | object    | Object to handle basic authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| <type=web>           | password                            | string    | Password to use for the basic authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| <type=web>           | type                                | enum      | The type of basic authentication to use when performing the test. Allowed enum values: `web`. Default: `web`.                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| <type=web>           | username                            | string    | Username to use for the basic authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| basicAuth            | <type=sigv4>                        | object    | Object to handle `SIGV4` authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| <type=sigv4>         | accessKey [*required*]              | string    | Access key for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| <type=sigv4>         | region                              | string    | Region for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| <type=sigv4>         | secretKey [*required*]              | string    | Secret key for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| <type=sigv4>         | serviceName                         | string    | Service name for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| <type=sigv4>         | sessionToken                        | string    | Session token for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| <type=sigv4>         | type [*required*]                   | enum      | The type of authentication to use when performing the test. Allowed enum values: `sigv4`. Default: `sigv4`.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| basicAuth            | <type=ntlm>                         | object    | Object to handle `NTLM` authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=ntlm>          | domain                              | string    | Domain for the authentication to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <type=ntlm>          | password                            | string    | Password for the authentication to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=ntlm>          | type [*required*]                   | enum      | The type of authentication to use when performing the test. Allowed enum values: `ntlm`. Default: `ntlm`.                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| <type=ntlm>          | username                            | string    | Username for the authentication to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=ntlm>          | workstation                         | string    | Workstation for the authentication to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| basicAuth            | <type=digest>                       | object    | Object to handle digest authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=digest>        | password [*required*]               | string    | Password to use for the digest authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <type=digest>        | type [*required*]                   | enum      | The type of basic authentication to use when performing the test. Allowed enum values: `digest`. Default: `digest`.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=digest>        | username [*required*]               | string    | Username to use for the digest authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| basicAuth            | <type=oauth-client>                 | object    | Object to handle `oauth client` authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| <type=oauth-client>  | accessTokenUrl [*required*]         | string    | Access token URL to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| <type=oauth-client>  | audience                            | string    | Audience to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-client>  | clientId [*required*]               | string    | Client ID to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| <type=oauth-client>  | clientSecret [*required*]           | string    | Client secret to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| <type=oauth-client>  | resource                            | string    | Resource to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-client>  | scope                               | string    | Scope to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=oauth-client>  | tokenApiAuthentication [*required*] | enum      | Type of token to use when performing the authentication. Allowed enum values: `header`, `body`.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| <type=oauth-client>  | type [*required*]                   | enum      | The type of basic authentication to use when performing the test. Allowed enum values: `oauth-client`. Default: `oauth-client`.                                                                                                                                                                                                                                                                                                                                                                                                                              |
| basicAuth            | <type=oauth-rop>                    | object    | Object to handle `oauth rop` authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| <type=oauth-rop>     | accessTokenUrl [*required*]         | string    | Access token URL to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| <type=oauth-rop>     | audience                            | string    | Audience to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-rop>     | clientId                            | string    | Client ID to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| <type=oauth-rop>     | clientSecret                        | string    | Client secret to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| <type=oauth-rop>     | password [*required*]               | string    | Password to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-rop>     | resource                            | string    | Resource to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-rop>     | scope                               | string    | Scope to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=oauth-rop>     | tokenApiAuthentication [*required*] | enum      | Type of token to use when performing the authentication. Allowed enum values: `header`, `body`.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| <type=oauth-rop>     | type [*required*]                   | enum      | The type of basic authentication to use when performing the test. Allowed enum values: `oauth-rop`. Default: `oauth-rop`.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| <type=oauth-rop>     | username [*required*]               | string    | Username to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| basicAuth            | <type=jwt>                          | object    | Object to handle JWT authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| <type=jwt>           | addClaims                           | object    | Standard JWT claims to automatically inject.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| addClaims            | exp                                 | boolean   | Whether to inject the `exp` (expiration) claim.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| addClaims            | iat                                 | boolean   | Whether to inject the `iat` (issued at) claim.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <type=jwt>           | algorithm [*required*]              | enum      | Algorithm to use for the JWT authentication. Allowed enum values: `HS256`, `RS256`, `ES256`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| <type=jwt>           | expiresIn                           | int64     | Token time-to-live in seconds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <type=jwt>           | header                              | string    | Custom JWT header as a JSON string.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=jwt>           | payload [*required*]                | string    | JWT claims as a JSON string.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| <type=jwt>           | secret [*required*]                 | string    | Signing key for the JWT authentication. Use the shared secret for `HS256` or the private key (PEM format) for `RS256` and `ES256`.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| <type=jwt>           | tokenPrefix                         | string    | Prefix added before the token in the `Authorization` header. Defaults to `Bearer`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| <type=jwt>           | type [*required*]                   | enum      | The type of authentication to use when performing the test. Allowed enum values: `jwt`. Default: `jwt`.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| request              | body                                | string    | Body to include in the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| request              | bodyType                            | enum      | Type of the request body. Allowed enum values: `text/plain`, `application/json`, `text/xml`, `text/html`, `application/x-www-form-urlencoded`, `graphql`, `application/octet-stream`, `multipart/form-data`.                                                                                                                                                                                                                                                                                                                                                 |
| request              | callType                            | enum      | The type of call to perform. Used by gRPC steps (`healthcheck`, `unary`) and MCP steps (`init`, `tool_list`, `tool_call`). Valid values depend on the parent step's `subtype`. Allowed enum values: `healthcheck`, `unary`, `init`, `tool_list`, `tool_call`.                                                                                                                                                                                                                                                                                                |
| request              | certificate                         | object    | Client certificate to use when performing the test request.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| certificate          | cert                                | object    | Define a request certificate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| cert                 | content                             | string    | Content of the certificate or key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| cert                 | filename                            | string    | File name for the certificate or key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| cert                 | updatedAt                           | string    | Date of update of the certificate or key, ISO format.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| certificate          | key                                 | object    | Define a request certificate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| key                  | content                             | string    | Content of the certificate or key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| key                  | filename                            | string    | File name for the certificate or key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| key                  | updatedAt                           | string    | Date of update of the certificate or key, ISO format.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| request              | certificateDomains                  | [string]  | By default, the client certificate is applied on the domain of the starting URL for browser tests. If you want your client certificate to be applied on other domains instead, add them in `certificateDomains`.                                                                                                                                                                                                                                                                                                                                             |
| request              | checkCertificateRevocation          | boolean   | Check for certificate revocation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| request              | compressedJsonDescriptor            | string    | A protobuf JSON descriptor that needs to be gzipped first then base64 encoded.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| request              | compressedProtoFile                 | string    | A protobuf file that needs to be gzipped first then base64 encoded.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| request              | disableAiaIntermediateFetching      | boolean   | Disable fetching intermediate certificates from AIA.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| request              | dnsServer                           | string    | DNS server to use for DNS tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| request              | dnsServerPort                       | <oneOf>   | DNS server port to use for DNS tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| dnsServerPort        | Object 1                            | int64     | Integer DNS server port number to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| dnsServerPort        | Object 2                            | string    | String DNS server port number to use when performing the test. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| request              | files                               | [object]  | Files to be used as part of the request in the test. Only valid if `bodyType` is `multipart/form-data`.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| files                | bucketKey                           | string    | Bucket key of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| files                | content                             | string    | Content of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| files                | encoding                            | string    | Encoding of the file content. The only supported value is `base64`, indicating the `content` field contains base64-encoded data.                                                                                                                                                                                                                                                                                                                                                                                                                             |
| files                | name                                | string    | Name of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| files                | originalFileName                    | string    | Original name of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| files                | size                                | int64     | Size of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| files                | type                                | string    | Type of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| request              | follow_redirects                    | boolean   | Specifies whether or not the request follows redirects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| request              | form                                | object    | Form to be used as part of the request in the test. Only valid if `bodyType` is `multipart/form-data`.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| additionalProperties | <any-key>                           | string    | A single form entry.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| request              | headers                             | object    | Headers to include when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| additionalProperties | <any-key>                           | string    | A single Header.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| request              | host                                | string    | Host name to perform the test with.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| request              | httpVersion                         | enum      | HTTP version to use for a Synthetic test. Allowed enum values: `http1`, `http2`, `any`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| request              | ignore_certificate_validation       | boolean   | For SSL tests, whether the test should ignore certificate validation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| request              | isMessageBase64Encoded              | boolean   | Whether the message is base64 encoded.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| request              | mcpProtocolVersion                  | enum      | The MCP protocol version used by the step. See <https://modelcontextprotocol.io/specification>. Allowed enum values: `2025-06-18`.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| request              | message                             | string    | Message to send for UDP or WebSocket tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| request              | metadata                            | object    | Metadata to include when performing the gRPC test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| additionalProperties | <any-key>                           | string    | A single metadatum.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| request              | method                              | string    | Either the HTTP method/verb to use or a gRPC method available on the service set in the `service` field. Required if `subtype` is `HTTP` or if `subtype` is `grpc` and `callType` is `unary`.                                                                                                                                                                                                                                                                                                                                                                |
| request              | noSavingResponseBody                | boolean   | Determines whether or not to save the response body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| request              | numberOfPackets                     | int32     | Number of pings to use per test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| request              | persistCookies                      | boolean   | Persist cookies across redirects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| request              | port                                | <oneOf>   | Port to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| port                 | Object 1                            | int64     | Integer Port number to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| port                 | Object 2                            | string    | String Port number to use when performing the test. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| request              | proxy                               | object    | The proxy to perform the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| proxy                | headers                             | object    | Headers to include when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| additionalProperties | <any-key>                           | string    | A single Header.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| proxy                | url [*required*]                    | string    | URL of the proxy to perform the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| request              | query                               | object    | Query to use for the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| request              | servername                          | string    | For SSL tests, it specifies on which server you want to initiate the TLS handshake, allowing the server to present one of multiple possible certificates on the same IP address and TCP port number.                                                                                                                                                                                                                                                                                                                                                         |
| request              | service                             | string    | The gRPC service on which you want to perform the gRPC call.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| request              | shouldTrackHops                     | boolean   | Turns on a traceroute probe to discover all gateways along the path to the host destination.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| request              | timeout                             | double    | Timeout in seconds for the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| request              | toolArgs                            | object    | Arguments to pass to the MCP tool. Free-form object whose shape depends on the tool. Used when `callType` is `tool_call`.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| request              | toolName                            | string    | The name of the MCP tool to call. Required when `callType` is `tool_call`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| request              | url                                 | string    | URL to perform the test with.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| config               | variables                           | [object]  | Browser tests only - array of variables used for the test steps.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| variables            | example                             | string    | Example for the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| variables            | id                                  | string    | ID for the variable. Global variables require an ID.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| variables            | name [*required*]                   | string    | Name of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| variables            | pattern                             | string    | Pattern of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| variables            | secure                              | boolean   | Determines whether or not the browser test variable is obfuscated. Can only be used with browser variables of type `text`.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| variables            | type [*required*]                   | enum      | Type of browser test variable. Allowed enum values: `element`, `email`, `global`, `text`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                      | locations                           | [string]  | Array of locations used to run the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                      | message                             | string    | Notification message associated with the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                      | name                                | string    | Name of the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|                      | options                             | object    | Object describing the extra options for a Synthetic test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| options              | accept_self_signed                  | boolean   | For SSL tests, whether or not the test should allow self signed certificates.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| options              | allow_insecure                      | boolean   | Allows loading insecure content for an HTTP request in an API test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | bits_ai_auto_investigate            | boolean   | Whether Bits AI automatically investigates alerts from the test monitor.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| options              | blockedRequestPatterns              | [string]  | Array of URL patterns to block.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| options              | captureNetworkPayloads              | boolean   | Capture HTTP request/response headers and bodies for Fetch/XHR calls made during browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| options              | checkCertificateRevocation          | boolean   | For SSL tests, whether or not the test should fail on revoked certificate in stapled OCSP.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| options              | ci                                  | object    | CI/CD options for a Synthetic test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ci                   | executionRule [*required*]          | enum      | Execution rule for a Synthetic test. Allowed enum values: `blocking`, `non_blocking`, `skipped`.                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| options              | device_ids                          | [string]  | For browser test, array with the different device IDs used to run the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| options              | disableAiaIntermediateFetching      | boolean   | For SSL tests, whether or not the test should disable fetching intermediate certificates from AIA.                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| options              | disableCors                         | boolean   | Whether or not to disable CORS mechanism.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| options              | disableCsp                          | boolean   | Disable Content Security Policy for browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| options              | enableProfiling                     | boolean   | Enable profiling for browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | enableSecurityTesting               | boolean   | **DEPRECATED**: Enable security testing for browser tests. Security testing is not available anymore. This field is deprecated and won't be used.                                                                                                                                                                                                                                                                                                                                                                                                            |
| options              | follow_redirects                    | boolean   | For API HTTP test, whether or not the test should follow redirects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | httpVersion                         | enum      | HTTP version to use for a Synthetic test. Allowed enum values: `http1`, `http2`, `any`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| options              | ignoreServerCertificateError        | boolean   | Ignore server certificate error for browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| options              | ignore_certificate_validation       | boolean   | For SSL tests, whether the test should ignore certificate validation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| options              | initialNavigationTimeout            | int64     | Timeout before declaring the initial step as failed (in seconds) for browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | min_failure_duration                | int64     | Minimum amount of time in failure required to trigger an alert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| options              | min_location_failed                 | int64     | Minimum number of locations in failure required to trigger an alert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| options              | monitor_name                        | string    | The monitor name is used for the alert title as well as for all monitor dashboard widgets and SLOs.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | monitor_options                     | object    | Object containing the options for a Synthetic test as a monitor (for example, renotification).                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| monitor_options      | escalation_message                  | string    | Message to include in the escalation notification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| monitor_options      | notification_preset_name            | enum      | The name of the preset for the notification for the monitor. Allowed enum values: `show_all`, `hide_all`, `hide_query`, `hide_handles`, `hide_query_and_handles`, `show_only_snapshot`, `hide_handles_and_footer`.                                                                                                                                                                                                                                                                                                                                           |
| monitor_options      | renotify_interval                   | int64     | Time interval before renotifying if the test is still failing (in minutes).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| monitor_options      | renotify_occurrences                | int64     | The number of times to renotify if the test is still failing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| options              | monitor_priority                    | int32     | Integer from 1 (high) to 5 (low) indicating alert severity.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| options              | noScreenshot                        | boolean   | Prevents saving screenshots of the steps.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| options              | restricted_roles                    | [string]  | **DEPRECATED**: A list of role identifiers that can be pulled from the Roles API, for restricting read and write access. This field is deprecated. Use the restriction policies API to manage permissions.                                                                                                                                                                                                                                                                                                                                                   |
| options              | retry                               | object    | Object describing the retry strategy to apply to a Synthetic test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| retry                | count                               | int64     | Number of times a test needs to be retried before marking a location as failed. Defaults to 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| retry                | interval                            | double    | Time interval between retries (in milliseconds). Defaults to 300ms.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | rumSettings                         | object    | The RUM data collection settings for the Synthetic browser test. **Note:** There are 3 ways to format RUM settings: `{ isEnabled: false }` RUM data is not collected. `{ isEnabled: true }` RUM data is collected from the Synthetic test's default application. `{ isEnabled: true, applicationId: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", clientTokenId: 12345 }` RUM data is collected using the specified application.                                                                                                                                   |
| rumSettings          | applicationId                       | string    | RUM application ID used to collect RUM data for the browser test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| rumSettings          | clientTokenId                       | int64     | RUM application API key ID used to collect RUM data for the browser test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| rumSettings          | isEnabled [*required*]              | boolean   | Determines whether RUM data is collected during test runs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| options              | scheduling                          | object    | Object containing timeframes and timezone used for advanced scheduling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| scheduling           | timeframes [*required*]             | [object]  | Array containing objects describing the scheduling pattern to apply to each day.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| timeframes           | day [*required*]                    | int32     | Number representing the day of the week.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| timeframes           | from [*required*]                   | string    | The hour of the day on which scheduling starts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| timeframes           | to [*required*]                     | string    | The hour of the day on which scheduling ends.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| scheduling           | timezone [*required*]               | string    | Timezone in which the timeframe is based.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| options              | tick_every                          | int64     | The frequency at which to run the Synthetic test (in seconds).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                      | status                              | enum      | Define whether you want to start (`live`) or pause (`paused`) a Synthetic test. Allowed enum values: `live`, `paused`.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                      | steps                               | [object]  | The steps of the test if they exist.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| steps                | allowFailure                        | boolean   | A boolean set to allow this step to fail.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| steps                | alwaysExecute                       | boolean   | A boolean set to always execute this step even if the previous step failed or was skipped.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| steps                | exitIfSucceed                       | boolean   | A boolean set to exit the test if the step succeeds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| steps                | isCritical                          | boolean   | A boolean to use in addition to `allowFailure` to determine if the test should be marked as failed when the step fails.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| steps                | name                                | string    | The name of the step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| steps                | noScreenshot                        | boolean   | A boolean set to skip taking a screenshot for the step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| steps                | params                              | object    | The parameters of the step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| steps                | public_id                           | string    | The public ID of the step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| steps                | timeout                             | int64     | The time before declaring a step failed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| steps                | type                                | enum      | Step type used in your Synthetic test. Allowed enum values: `assertCurrentUrl`, `assertElementAttribute`, `assertElementContent`, `assertElementPresent`, `assertEmail`, `assertFileDownload`, `assertFromJavascript`, `assertPageContains`, `assertPageLacks`, `assertRequests`, `click`, `drag`, `drop`, `extractFromJavascript`, `extractFromEmailBody`, `extractVariable`, `goToEmailLink`, `goToUrl`, `goToUrlAndMeasureTti`, `hover`, `playSubTest`, `pressKey`, `refresh`, `runApiTest`, `scroll`, `selectOption`, `typeText`, `uploadFiles`, `wait`. |
|                      | subtype                             | enum      | The subtype of the Synthetic API test, `http`, `ssl`, `tcp`, `dns`, `icmp`, `udp`, `websocket`, `grpc` or `multi`. Allowed enum values: `http`, `ssl`, `tcp`, `dns`, `multi`, `icmp`, `udp`, `websocket`, `grpc`.                                                                                                                                                                                                                                                                                                                                            |
|                      | tags                                | [string]  | Array of tags attached to the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                      | type                                | enum      | Type of the Synthetic test. Allowed enum values: `api`, `browser`, `mobile`, `network`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
{% /tab %}

{% tab label="Example" %}
```json
{
  "config": {
    "assertions": [
      {
        "operator": "contains",
        "property": "string",
        "target": 0,
        "timingsScope": "string",
        "type": "statusCode"
      }
    ],
    "configVariables": [
      {
        "example": "string",
        "id": "string",
        "name": "VARIABLE_NAME",
        "pattern": "string",
        "secure": false,
        "type": "text"
      }
    ],
    "request": {
      "allow_insecure": false,
      "basicAuth": {
        "password": "PaSSw0RD!",
        "type": "web",
        "username": "my_username"
      },
      "body": "string",
      "bodyType": "text/plain",
      "callType": "unary",
      "certificate": {
        "cert": {
          "content": "string",
          "filename": "string",
          "updatedAt": "string"
        },
        "key": {
          "content": "string",
          "filename": "string",
          "updatedAt": "string"
        }
      },
      "certificateDomains": [],
      "checkCertificateRevocation": false,
      "compressedJsonDescriptor": "string",
      "compressedProtoFile": "string",
      "disableAiaIntermediateFetching": false,
      "dnsServer": "string",
      "dnsServerPort": {
        "description": "undefined",
        "format": "undefined",
        "type": "undefined"
      },
      "files": [
        {
          "bucketKey": "string",
          "content": "string",
          "encoding": "string",
          "name": "string",
          "originalFileName": "string",
          "size": "integer",
          "type": "string"
        }
      ],
      "follow_redirects": false,
      "form": {
        "<any-key>": "string"
      },
      "headers": {
        "<any-key>": "string"
      },
      "host": "string",
      "httpVersion": "string",
      "ignore_certificate_validation": false,
      "isMessageBase64Encoded": false,
      "mcpProtocolVersion": "2025-06-18",
      "message": "string",
      "metadata": {
        "<any-key>": "string"
      },
      "method": "string",
      "noSavingResponseBody": false,
      "numberOfPackets": "integer",
      "persistCookies": false,
      "port": {
        "description": "undefined",
        "format": "undefined",
        "type": "undefined"
      },
      "proxy": {
        "headers": {
          "<any-key>": "string"
        },
        "url": "https://example.com"
      },
      "query": {},
      "servername": "string",
      "service": "Greeter",
      "shouldTrackHops": false,
      "timeout": "number",
      "toolArgs": {},
      "toolName": "search",
      "url": "https://example.com"
    },
    "variables": [
      {
        "example": "string",
        "id": "string",
        "name": "VARIABLE_NAME",
        "pattern": "string",
        "secure": false,
        "type": "text"
      }
    ]
  },
  "locations": [
    "aws:eu-west-3"
  ],
  "message": "string",
  "name": "string",
  "options": {
    "accept_self_signed": false,
    "allow_insecure": false,
    "bits_ai_auto_investigate": false,
    "blockedRequestPatterns": [],
    "captureNetworkPayloads": false,
    "checkCertificateRevocation": false,
    "ci": {
      "executionRule": "blocking"
    },
    "device_ids": [
      "chrome.laptop_large"
    ],
    "disableAiaIntermediateFetching": false,
    "disableCors": false,
    "disableCsp": false,
    "enableProfiling": false,
    "enableSecurityTesting": false,
    "follow_redirects": false,
    "httpVersion": "string",
    "ignoreServerCertificateError": false,
    "ignore_certificate_validation": false,
    "initialNavigationTimeout": "integer",
    "min_failure_duration": "integer",
    "min_location_failed": "integer",
    "monitor_name": "string",
    "monitor_options": {
      "escalation_message": "string",
      "notification_preset_name": "string",
      "renotify_interval": "integer",
      "renotify_occurrences": "integer"
    },
    "monitor_priority": "integer",
    "noScreenshot": false,
    "restricted_roles": [
      "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
    ],
    "retry": {
      "count": "integer",
      "interval": "number"
    },
    "rumSettings": {
      "applicationId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "clientTokenId": 12345,
      "isEnabled": true
    },
    "scheduling": {
      "timeframes": [
        {
          "day": 1,
          "from": "07:00",
          "to": "16:00"
        }
      ],
      "timezone": "America/New_York"
    },
    "tick_every": "integer"
  },
  "status": "live",
  "steps": [
    {
      "allowFailure": false,
      "alwaysExecute": false,
      "exitIfSucceed": false,
      "isCritical": false,
      "name": "string",
      "noScreenshot": false,
      "params": {},
      "public_id": "string",
      "timeout": "integer",
      "type": "assertElementContent"
    }
  ],
  "subtype": "http",
  "tags": [],
  "type": "string"
}
```
{% /tab %}
{% /tabs %}

### Response

{% tabs %}
{% tab label="200" %}
OK - Returns the created test details.

{% tabs %}
{% tab label="Model" %}
Object containing details about your Synthetic test.

| Parent field         | Field                               | Type      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| -------------------- | ----------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|                      | config                              | object    | Configuration object for a Synthetic test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| config               | assertions                          | [<oneOf>] | Array of assertions used for the test. Required for single API tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| assertions           | Object 1                            | object    | An assertion which uses a simple target.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Object 1             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `contains`, `doesNotContain`, `is`, `isNot`, `lessThan`, `lessThanOrEqual`, `moreThan`, `moreThanOrEqual`, `matches`, `doesNotMatch`, `validates`, `isInMoreThan`, `isInLessThan`, `doesNotExist`, `isUndefined`.                                                                                                                                                                                                                                                                                          |
| Object 1             | property                            | string    | The associated assertion property.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 1             | target [*required*]                 | <oneOf>   | Value used by the operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| target               | Object 1                            | double    | Numeric value used by the operator in assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| target               | Object 2                            | string    | String value used by the operator in assertions. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Object 1             | timingsScope                        | enum      | Timings scope for response time assertions. Allowed enum values: `all`, `withoutDNS`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Object 1             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `body`, `header`, `statusCode`, `certificate`, `responseTime`, `property`, `recordEvery`, `recordSome`, `tlsVersion`, `minTlsVersion`, `latency`, `packetLossPercentage`, `packetsReceived`, `networkHop`, `receivedMessage`, `grpcHealthcheckStatus`, `grpcMetadata`, `grpcProto`, `connection`, `multiNetworkHop`, `jitter`, `mcpToolNameLength`, `mcpToolCount`.                                                                                                                                              |
| assertions           | Object 2                            | object    | An assertion which targets body hash.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Object 2             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `md5`, `sha1`, `sha256`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Object 2             | target [*required*]                 | <oneOf>   | Value used by the operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| target               | Object 1                            | double    | Numeric value used by the operator in assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| target               | Object 2                            | string    | String value used by the operator in assertions. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Object 2             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `bodyHash`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| assertions           | Object 3                            | object    | An assertion for the `validatesJSONPath` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 3             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `validatesJSONPath`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Object 3             | property                            | string    | The associated assertion property.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 3             | target                              | object    | Composed target for `validatesJSONPath` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| target               | elementsOperator                    | string    | The element from the list of results to assert on.  To choose from the first element in the list `firstElementMatches`, every element in the list `everyElementMatches`, at least one element in the list `atLeastOneElementMatches` or the serialized value of the list `serializationMatches`.                                                                                                                                                                                                                                                             |
| target               | jsonPath                            | string    | The JSON path to assert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| target               | operator                            | string    | The specific operator to use on the path.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| target               | targetValue                         | <oneOf>   | The path target value to compare to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| targetValue          | Object 1                            | double    | Numeric value used by the operator in assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| targetValue          | Object 2                            | string    | String value used by the operator in assertions. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Object 3             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `body`, `header`, `statusCode`, `certificate`, `responseTime`, `property`, `recordEvery`, `recordSome`, `tlsVersion`, `minTlsVersion`, `latency`, `packetLossPercentage`, `packetsReceived`, `networkHop`, `receivedMessage`, `grpcHealthcheckStatus`, `grpcMetadata`, `grpcProto`, `connection`, `multiNetworkHop`, `jitter`, `mcpToolNameLength`, `mcpToolCount`.                                                                                                                                              |
| assertions           | Object 4                            | object    | An assertion for the `validatesJSONSchema` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Object 4             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `validatesJSONSchema`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Object 4             | target                              | object    | Composed target for `validatesJSONSchema` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| target               | jsonSchema                          | string    | The JSON Schema to assert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| target               | metaSchema                          | enum      | The JSON Schema meta-schema version used in the assertion. Allowed enum values: `draft-07`, `draft-06`.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Object 4             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `body`, `header`, `statusCode`, `certificate`, `responseTime`, `property`, `recordEvery`, `recordSome`, `tlsVersion`, `minTlsVersion`, `latency`, `packetLossPercentage`, `packetsReceived`, `networkHop`, `receivedMessage`, `grpcHealthcheckStatus`, `grpcMetadata`, `grpcProto`, `connection`, `multiNetworkHop`, `jitter`, `mcpToolNameLength`, `mcpToolCount`.                                                                                                                                              |
| assertions           | Object 5                            | object    | An assertion for the `validatesXPath` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Object 5             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `validatesXPath`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Object 5             | property                            | string    | The associated assertion property.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 5             | target                              | object    | Composed target for `validatesXPath` operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| target               | operator                            | string    | The specific operator to use on the path.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| target               | targetValue                         | <oneOf>   | The path target value to compare to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| targetValue          | Object 1                            | double    | Numeric value used by the operator in assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| targetValue          | Object 2                            | string    | String value used by the operator in assertions. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| target               | xPath                               | string    | The X path to assert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Object 5             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `body`, `header`, `statusCode`, `certificate`, `responseTime`, `property`, `recordEvery`, `recordSome`, `tlsVersion`, `minTlsVersion`, `latency`, `packetLossPercentage`, `packetsReceived`, `networkHop`, `receivedMessage`, `grpcHealthcheckStatus`, `grpcMetadata`, `grpcProto`, `connection`, `multiNetworkHop`, `jitter`, `mcpToolNameLength`, `mcpToolCount`.                                                                                                                                              |
| assertions           | Object 6                            | object    | A JavaScript assertion.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Object 6             | code [*required*]                   | string    | The JavaScript code that performs the assertions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Object 6             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `javascript`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| assertions           | Object 7                            | object    | An assertion that checks that an MCP server advertises the expected capabilities.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Object 7             | operator [*required*]               | enum      | Assertion operator to apply. Allowed enum values: `contains`, `doesNotContain`, `is`, `isNot`, `lessThan`, `lessThanOrEqual`, `moreThan`, `moreThanOrEqual`, `matches`, `doesNotMatch`, `validates`, `isInMoreThan`, `isInLessThan`, `doesNotExist`, `isUndefined`.                                                                                                                                                                                                                                                                                          |
| Object 7             | target [*required*]                 | [string]  | List of MCP server capabilities to assert against.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 7             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `mcpServerCapabilities`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| assertions           | Object 8                            | object    | An assertion that verifies the MCP server response respects the MCP specification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Object 8             | type [*required*]                   | enum      | Type of the assertion. Allowed enum values: `mcpRespectsSpecification`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| config               | configVariables                     | [object]  | Array of variables used for the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| configVariables      | example                             | string    | Example for the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| configVariables      | id                                  | string    | ID of the variable for global variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| configVariables      | name [*required*]                   | string    | Name of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| configVariables      | pattern                             | string    | Pattern of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| configVariables      | secure                              | boolean   | Whether the value of this variable will be obfuscated in test results. Only for config variables of type `text`.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| configVariables      | type [*required*]                   | enum      | Type of the configuration variable. Allowed enum values: `global`, `text`, `email`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| config               | request                             | object    | Object describing the Synthetic test request.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| request              | allow_insecure                      | boolean   | Allows loading insecure content for an HTTP request in a multistep test step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| request              | basicAuth                           | <oneOf>   | Object to handle basic authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| basicAuth            | <type=web>                          | object    | Object to handle basic authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| <type=web>           | password                            | string    | Password to use for the basic authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| <type=web>           | type                                | enum      | The type of basic authentication to use when performing the test. Allowed enum values: `web`. Default: `web`.                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| <type=web>           | username                            | string    | Username to use for the basic authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| basicAuth            | <type=sigv4>                        | object    | Object to handle `SIGV4` authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| <type=sigv4>         | accessKey [*required*]              | string    | Access key for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| <type=sigv4>         | region                              | string    | Region for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| <type=sigv4>         | secretKey [*required*]              | string    | Secret key for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| <type=sigv4>         | serviceName                         | string    | Service name for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| <type=sigv4>         | sessionToken                        | string    | Session token for the `SIGV4` authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| <type=sigv4>         | type [*required*]                   | enum      | The type of authentication to use when performing the test. Allowed enum values: `sigv4`. Default: `sigv4`.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| basicAuth            | <type=ntlm>                         | object    | Object to handle `NTLM` authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=ntlm>          | domain                              | string    | Domain for the authentication to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <type=ntlm>          | password                            | string    | Password for the authentication to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=ntlm>          | type [*required*]                   | enum      | The type of authentication to use when performing the test. Allowed enum values: `ntlm`. Default: `ntlm`.                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| <type=ntlm>          | username                            | string    | Username for the authentication to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=ntlm>          | workstation                         | string    | Workstation for the authentication to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| basicAuth            | <type=digest>                       | object    | Object to handle digest authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=digest>        | password [*required*]               | string    | Password to use for the digest authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <type=digest>        | type [*required*]                   | enum      | The type of basic authentication to use when performing the test. Allowed enum values: `digest`. Default: `digest`.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=digest>        | username [*required*]               | string    | Username to use for the digest authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| basicAuth            | <type=oauth-client>                 | object    | Object to handle `oauth client` authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| <type=oauth-client>  | accessTokenUrl [*required*]         | string    | Access token URL to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| <type=oauth-client>  | audience                            | string    | Audience to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-client>  | clientId [*required*]               | string    | Client ID to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| <type=oauth-client>  | clientSecret [*required*]           | string    | Client secret to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| <type=oauth-client>  | resource                            | string    | Resource to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-client>  | scope                               | string    | Scope to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=oauth-client>  | tokenApiAuthentication [*required*] | enum      | Type of token to use when performing the authentication. Allowed enum values: `header`, `body`.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| <type=oauth-client>  | type [*required*]                   | enum      | The type of basic authentication to use when performing the test. Allowed enum values: `oauth-client`. Default: `oauth-client`.                                                                                                                                                                                                                                                                                                                                                                                                                              |
| basicAuth            | <type=oauth-rop>                    | object    | Object to handle `oauth rop` authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| <type=oauth-rop>     | accessTokenUrl [*required*]         | string    | Access token URL to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| <type=oauth-rop>     | audience                            | string    | Audience to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-rop>     | clientId                            | string    | Client ID to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| <type=oauth-rop>     | clientSecret                        | string    | Client secret to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| <type=oauth-rop>     | password [*required*]               | string    | Password to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-rop>     | resource                            | string    | Resource to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=oauth-rop>     | scope                               | string    | Scope to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| <type=oauth-rop>     | tokenApiAuthentication [*required*] | enum      | Type of token to use when performing the authentication. Allowed enum values: `header`, `body`.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| <type=oauth-rop>     | type [*required*]                   | enum      | The type of basic authentication to use when performing the test. Allowed enum values: `oauth-rop`. Default: `oauth-rop`.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| <type=oauth-rop>     | username [*required*]               | string    | Username to use when performing the authentication.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| basicAuth            | <type=jwt>                          | object    | Object to handle JWT authentication when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| <type=jwt>           | addClaims                           | object    | Standard JWT claims to automatically inject.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| addClaims            | exp                                 | boolean   | Whether to inject the `exp` (expiration) claim.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| addClaims            | iat                                 | boolean   | Whether to inject the `iat` (issued at) claim.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <type=jwt>           | algorithm [*required*]              | enum      | Algorithm to use for the JWT authentication. Allowed enum values: `HS256`, `RS256`, `ES256`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| <type=jwt>           | expiresIn                           | int64     | Token time-to-live in seconds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <type=jwt>           | header                              | string    | Custom JWT header as a JSON string.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <type=jwt>           | payload [*required*]                | string    | JWT claims as a JSON string.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| <type=jwt>           | secret [*required*]                 | string    | Signing key for the JWT authentication. Use the shared secret for `HS256` or the private key (PEM format) for `RS256` and `ES256`.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| <type=jwt>           | tokenPrefix                         | string    | Prefix added before the token in the `Authorization` header. Defaults to `Bearer`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| <type=jwt>           | type [*required*]                   | enum      | The type of authentication to use when performing the test. Allowed enum values: `jwt`. Default: `jwt`.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| request              | body                                | string    | Body to include in the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| request              | bodyType                            | enum      | Type of the request body. Allowed enum values: `text/plain`, `application/json`, `text/xml`, `text/html`, `application/x-www-form-urlencoded`, `graphql`, `application/octet-stream`, `multipart/form-data`.                                                                                                                                                                                                                                                                                                                                                 |
| request              | callType                            | enum      | The type of call to perform. Used by gRPC steps (`healthcheck`, `unary`) and MCP steps (`init`, `tool_list`, `tool_call`). Valid values depend on the parent step's `subtype`. Allowed enum values: `healthcheck`, `unary`, `init`, `tool_list`, `tool_call`.                                                                                                                                                                                                                                                                                                |
| request              | certificate                         | object    | Client certificate to use when performing the test request.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| certificate          | cert                                | object    | Define a request certificate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| cert                 | content                             | string    | Content of the certificate or key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| cert                 | filename                            | string    | File name for the certificate or key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| cert                 | updatedAt                           | string    | Date of update of the certificate or key, ISO format.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| certificate          | key                                 | object    | Define a request certificate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| key                  | content                             | string    | Content of the certificate or key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| key                  | filename                            | string    | File name for the certificate or key.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| key                  | updatedAt                           | string    | Date of update of the certificate or key, ISO format.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| request              | certificateDomains                  | [string]  | By default, the client certificate is applied on the domain of the starting URL for browser tests. If you want your client certificate to be applied on other domains instead, add them in `certificateDomains`.                                                                                                                                                                                                                                                                                                                                             |
| request              | checkCertificateRevocation          | boolean   | Check for certificate revocation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| request              | compressedJsonDescriptor            | string    | A protobuf JSON descriptor that needs to be gzipped first then base64 encoded.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| request              | compressedProtoFile                 | string    | A protobuf file that needs to be gzipped first then base64 encoded.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| request              | disableAiaIntermediateFetching      | boolean   | Disable fetching intermediate certificates from AIA.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| request              | dnsServer                           | string    | DNS server to use for DNS tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| request              | dnsServerPort                       | <oneOf>   | DNS server port to use for DNS tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| dnsServerPort        | Object 1                            | int64     | Integer DNS server port number to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| dnsServerPort        | Object 2                            | string    | String DNS server port number to use when performing the test. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| request              | files                               | [object]  | Files to be used as part of the request in the test. Only valid if `bodyType` is `multipart/form-data`.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| files                | bucketKey                           | string    | Bucket key of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| files                | content                             | string    | Content of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| files                | encoding                            | string    | Encoding of the file content. The only supported value is `base64`, indicating the `content` field contains base64-encoded data.                                                                                                                                                                                                                                                                                                                                                                                                                             |
| files                | name                                | string    | Name of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| files                | originalFileName                    | string    | Original name of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| files                | size                                | int64     | Size of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| files                | type                                | string    | Type of the file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| request              | follow_redirects                    | boolean   | Specifies whether or not the request follows redirects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| request              | form                                | object    | Form to be used as part of the request in the test. Only valid if `bodyType` is `multipart/form-data`.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| additionalProperties | <any-key>                           | string    | A single form entry.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| request              | headers                             | object    | Headers to include when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| additionalProperties | <any-key>                           | string    | A single Header.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| request              | host                                | string    | Host name to perform the test with.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| request              | httpVersion                         | enum      | HTTP version to use for a Synthetic test. Allowed enum values: `http1`, `http2`, `any`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| request              | ignore_certificate_validation       | boolean   | For SSL tests, whether the test should ignore certificate validation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| request              | isMessageBase64Encoded              | boolean   | Whether the message is base64 encoded.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| request              | mcpProtocolVersion                  | enum      | The MCP protocol version used by the step. See <https://modelcontextprotocol.io/specification>. Allowed enum values: `2025-06-18`.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| request              | message                             | string    | Message to send for UDP or WebSocket tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| request              | metadata                            | object    | Metadata to include when performing the gRPC test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| additionalProperties | <any-key>                           | string    | A single metadatum.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| request              | method                              | string    | Either the HTTP method/verb to use or a gRPC method available on the service set in the `service` field. Required if `subtype` is `HTTP` or if `subtype` is `grpc` and `callType` is `unary`.                                                                                                                                                                                                                                                                                                                                                                |
| request              | noSavingResponseBody                | boolean   | Determines whether or not to save the response body.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| request              | numberOfPackets                     | int32     | Number of pings to use per test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| request              | persistCookies                      | boolean   | Persist cookies across redirects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| request              | port                                | <oneOf>   | Port to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| port                 | Object 1                            | int64     | Integer Port number to use when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| port                 | Object 2                            | string    | String Port number to use when performing the test. Supports templated variables.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| request              | proxy                               | object    | The proxy to perform the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| proxy                | headers                             | object    | Headers to include when performing the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| additionalProperties | <any-key>                           | string    | A single Header.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| proxy                | url [*required*]                    | string    | URL of the proxy to perform the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| request              | query                               | object    | Query to use for the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| request              | servername                          | string    | For SSL tests, it specifies on which server you want to initiate the TLS handshake, allowing the server to present one of multiple possible certificates on the same IP address and TCP port number.                                                                                                                                                                                                                                                                                                                                                         |
| request              | service                             | string    | The gRPC service on which you want to perform the gRPC call.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| request              | shouldTrackHops                     | boolean   | Turns on a traceroute probe to discover all gateways along the path to the host destination.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| request              | timeout                             | double    | Timeout in seconds for the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| request              | toolArgs                            | object    | Arguments to pass to the MCP tool. Free-form object whose shape depends on the tool. Used when `callType` is `tool_call`.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| request              | toolName                            | string    | The name of the MCP tool to call. Required when `callType` is `tool_call`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| request              | url                                 | string    | URL to perform the test with.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| config               | variables                           | [object]  | Browser tests only - array of variables used for the test steps.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| variables            | example                             | string    | Example for the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| variables            | id                                  | string    | ID for the variable. Global variables require an ID.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| variables            | name [*required*]                   | string    | Name of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| variables            | pattern                             | string    | Pattern of the variable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| variables            | secure                              | boolean   | Determines whether or not the browser test variable is obfuscated. Can only be used with browser variables of type `text`.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| variables            | type [*required*]                   | enum      | Type of browser test variable. Allowed enum values: `element`, `email`, `global`, `text`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|                      | creator                             | object    | Object describing the creator of the shared element. Read-only.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| creator              | email                               | string    | Email of the creator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| creator              | handle                              | string    | Handle of the creator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| creator              | name                                | string    | Name of the creator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|                      | locations                           | [string]  | Array of locations used to run the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                      | message                             | string    | Notification message associated with the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                      | monitor_id                          | int64     | The associated monitor ID. Read-only.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                      | name                                | string    | Name of the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
|                      | options                             | object    | Object describing the extra options for a Synthetic test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| options              | accept_self_signed                  | boolean   | For SSL tests, whether or not the test should allow self signed certificates.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| options              | allow_insecure                      | boolean   | Allows loading insecure content for an HTTP request in an API test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | bits_ai_auto_investigate            | boolean   | Whether Bits AI automatically investigates alerts from the test monitor.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| options              | blockedRequestPatterns              | [string]  | Array of URL patterns to block.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| options              | captureNetworkPayloads              | boolean   | Capture HTTP request/response headers and bodies for Fetch/XHR calls made during browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| options              | checkCertificateRevocation          | boolean   | For SSL tests, whether or not the test should fail on revoked certificate in stapled OCSP.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| options              | ci                                  | object    | CI/CD options for a Synthetic test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ci                   | executionRule [*required*]          | enum      | Execution rule for a Synthetic test. Allowed enum values: `blocking`, `non_blocking`, `skipped`.                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| options              | device_ids                          | [string]  | For browser test, array with the different device IDs used to run the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| options              | disableAiaIntermediateFetching      | boolean   | For SSL tests, whether or not the test should disable fetching intermediate certificates from AIA.                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| options              | disableCors                         | boolean   | Whether or not to disable CORS mechanism.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| options              | disableCsp                          | boolean   | Disable Content Security Policy for browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| options              | enableProfiling                     | boolean   | Enable profiling for browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | enableSecurityTesting               | boolean   | **DEPRECATED**: Enable security testing for browser tests. Security testing is not available anymore. This field is deprecated and won't be used.                                                                                                                                                                                                                                                                                                                                                                                                            |
| options              | follow_redirects                    | boolean   | For API HTTP test, whether or not the test should follow redirects.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | httpVersion                         | enum      | HTTP version to use for a Synthetic test. Allowed enum values: `http1`, `http2`, `any`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| options              | ignoreServerCertificateError        | boolean   | Ignore server certificate error for browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| options              | ignore_certificate_validation       | boolean   | For SSL tests, whether the test should ignore certificate validation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| options              | initialNavigationTimeout            | int64     | Timeout before declaring the initial step as failed (in seconds) for browser tests.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | min_failure_duration                | int64     | Minimum amount of time in failure required to trigger an alert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| options              | min_location_failed                 | int64     | Minimum number of locations in failure required to trigger an alert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| options              | monitor_name                        | string    | The monitor name is used for the alert title as well as for all monitor dashboard widgets and SLOs.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | monitor_options                     | object    | Object containing the options for a Synthetic test as a monitor (for example, renotification).                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| monitor_options      | escalation_message                  | string    | Message to include in the escalation notification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| monitor_options      | notification_preset_name            | enum      | The name of the preset for the notification for the monitor. Allowed enum values: `show_all`, `hide_all`, `hide_query`, `hide_handles`, `hide_query_and_handles`, `show_only_snapshot`, `hide_handles_and_footer`.                                                                                                                                                                                                                                                                                                                                           |
| monitor_options      | renotify_interval                   | int64     | Time interval before renotifying if the test is still failing (in minutes).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| monitor_options      | renotify_occurrences                | int64     | The number of times to renotify if the test is still failing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| options              | monitor_priority                    | int32     | Integer from 1 (high) to 5 (low) indicating alert severity.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| options              | noScreenshot                        | boolean   | Prevents saving screenshots of the steps.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| options              | restricted_roles                    | [string]  | **DEPRECATED**: A list of role identifiers that can be pulled from the Roles API, for restricting read and write access. This field is deprecated. Use the restriction policies API to manage permissions.                                                                                                                                                                                                                                                                                                                                                   |
| options              | retry                               | object    | Object describing the retry strategy to apply to a Synthetic test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| retry                | count                               | int64     | Number of times a test needs to be retried before marking a location as failed. Defaults to 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| retry                | interval                            | double    | Time interval between retries (in milliseconds). Defaults to 300ms.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| options              | rumSettings                         | object    | The RUM data collection settings for the Synthetic browser test. **Note:** There are 3 ways to format RUM settings: `{ isEnabled: false }` RUM data is not collected. `{ isEnabled: true }` RUM data is collected from the Synthetic test's default application. `{ isEnabled: true, applicationId: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", clientTokenId: 12345 }` RUM data is collected using the specified application.                                                                                                                                   |
| rumSettings          | applicationId                       | string    | RUM application ID used to collect RUM data for the browser test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| rumSettings          | clientTokenId                       | int64     | RUM application API key ID used to collect RUM data for the browser test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| rumSettings          | isEnabled [*required*]              | boolean   | Determines whether RUM data is collected during test runs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| options              | scheduling                          | object    | Object containing timeframes and timezone used for advanced scheduling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| scheduling           | timeframes [*required*]             | [object]  | Array containing objects describing the scheduling pattern to apply to each day.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| timeframes           | day [*required*]                    | int32     | Number representing the day of the week.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| timeframes           | from [*required*]                   | string    | The hour of the day on which scheduling starts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| timeframes           | to [*required*]                     | string    | The hour of the day on which scheduling ends.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| scheduling           | timezone [*required*]               | string    | Timezone in which the timeframe is based.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| options              | tick_every                          | int64     | The frequency at which to run the Synthetic test (in seconds).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                      | public_id                           | string    | The test public ID. Read-only.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|                      | status                              | enum      | Define whether you want to start (`live`) or pause (`paused`) a Synthetic test. Allowed enum values: `live`, `paused`.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                      | steps                               | [object]  | The steps of the test if they exist.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| steps                | allowFailure                        | boolean   | A boolean set to allow this step to fail.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| steps                | alwaysExecute                       | boolean   | A boolean set to always execute this step even if the previous step failed or was skipped.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| steps                | exitIfSucceed                       | boolean   | A boolean set to exit the test if the step succeeds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| steps                | isCritical                          | boolean   | A boolean to use in addition to `allowFailure` to determine if the test should be marked as failed when the step fails.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| steps                | name                                | string    | The name of the step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| steps                | noScreenshot                        | boolean   | A boolean set to skip taking a screenshot for the step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| steps                | params                              | object    | The parameters of the step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| steps                | public_id                           | string    | The public ID of the step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| steps                | timeout                             | int64     | The time before declaring a step failed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| steps                | type                                | enum      | Step type used in your Synthetic test. Allowed enum values: `assertCurrentUrl`, `assertElementAttribute`, `assertElementContent`, `assertElementPresent`, `assertEmail`, `assertFileDownload`, `assertFromJavascript`, `assertPageContains`, `assertPageLacks`, `assertRequests`, `click`, `drag`, `drop`, `extractFromJavascript`, `extractFromEmailBody`, `extractVariable`, `goToEmailLink`, `goToUrl`, `goToUrlAndMeasureTti`, `hover`, `playSubTest`, `pressKey`, `refresh`, `runApiTest`, `scroll`, `selectOption`, `typeText`, `uploadFiles`, `wait`. |
|                      | subtype                             | enum      | The subtype of the Synthetic API test, `http`, `ssl`, `tcp`, `dns`, `icmp`, `udp`, `websocket`, `grpc` or `multi`. Allowed enum values: `http`, `ssl`, `tcp`, `dns`, `multi`, `icmp`, `udp`, `websocket`, `grpc`.                                                                                                                                                                                                                                                                                                                                            |
|                      | tags                                | [string]  | Array of tags attached to the test.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                      | type                                | enum      | Type of the Synthetic test. Allowed enum values: `api`, `browser`, `mobile`, `network`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
{% /tab %}

{% tab label="Example" %}
```json
{
  "config": {
    "assertions": [
      {
        "operator": "contains",
        "property": "string",
        "target": 0,
        "timingsScope": "string",
        "type": "statusCode"
      }
    ],
    "configVariables": [
      {
        "example": "string",
        "id": "string",
        "name": "VARIABLE_NAME",
        "pattern": "string",
        "secure": false,
        "type": "text"
      }
    ],
    "request": {
      "allow_insecure": false,
      "basicAuth": {
        "password": "PaSSw0RD!",
        "type": "web",
        "username": "my_username"
      },
      "body": "string",
      "bodyType": "text/plain",
      "callType": "unary",
      "certificate": {
        "cert": {
          "content": "string",
          "filename": "string",
          "updatedAt": "string"
        },
        "key": {
          "content": "string",
          "filename": "string",
          "updatedAt": "string"
        }
      },
      "certificateDomains": [],
      "checkCertificateRevocation": false,
      "compressedJsonDescriptor": "string",
      "compressedProtoFile": "string",
      "disableAiaIntermediateFetching": false,
      "dnsServer": "string",
      "dnsServerPort": {
        "description": "undefined",
        "format": "undefined",
        "type": "undefined"
      },
      "files": [
        {
          "bucketKey": "string",
          "content": "string",
          "encoding": "string",
          "name": "string",
          "originalFileName": "string",
          "size": "integer",
          "type": "string"
        }
      ],
      "follow_redirects": false,
      "form": {
        "<any-key>": "string"
      },
      "headers": {
        "<any-key>": "string"
      },
      "host": "string",
      "httpVersion": "string",
      "ignore_certificate_validation": false,
      "isMessageBase64Encoded": false,
      "mcpProtocolVersion": "2025-06-18",
      "message": "string",
      "metadata": {
        "<any-key>": "string"
      },
      "method": "string",
      "noSavingResponseBody": false,
      "numberOfPackets": "integer",
      "persistCookies": false,
      "port": {
        "description": "undefined",
        "format": "undefined",
        "type": "undefined"
      },
      "proxy": {
        "headers": {
          "<any-key>": "string"
        },
        "url": "https://example.com"
      },
      "query": {},
      "servername": "string",
      "service": "Greeter",
      "shouldTrackHops": false,
      "timeout": "number",
      "toolArgs": {},
      "toolName": "search",
      "url": "https://example.com"
    },
    "variables": [
      {
        "example": "string",
        "id": "string",
        "name": "VARIABLE_NAME",
        "pattern": "string",
        "secure": false,
        "type": "text"
      }
    ]
  },
  "creator": {
    "email": "string",
    "handle": "string",
    "name": "string"
  },
  "locations": [
    "aws:eu-west-3"
  ],
  "message": "string",
  "monitor_id": "integer",
  "name": "string",
  "options": {
    "accept_self_signed": false,
    "allow_insecure": false,
    "bits_ai_auto_investigate": false,
    "blockedRequestPatterns": [],
    "captureNetworkPayloads": false,
    "checkCertificateRevocation": false,
    "ci": {
      "executionRule": "blocking"
    },
    "device_ids": [
      "chrome.laptop_large"
    ],
    "disableAiaIntermediateFetching": false,
    "disableCors": false,
    "disableCsp": false,
    "enableProfiling": false,
    "enableSecurityTesting": false,
    "follow_redirects": false,
    "httpVersion": "string",
    "ignoreServerCertificateError": false,
    "ignore_certificate_validation": false,
    "initialNavigationTimeout": "integer",
    "min_failure_duration": "integer",
    "min_location_failed": "integer",
    "monitor_name": "string",
    "monitor_options": {
      "escalation_message": "string",
      "notification_preset_name": "string",
      "renotify_interval": "integer",
      "renotify_occurrences": "integer"
    },
    "monitor_priority": "integer",
    "noScreenshot": false,
    "restricted_roles": [
      "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
    ],
    "retry": {
      "count": "integer",
      "interval": "number"
    },
    "rumSettings": {
      "applicationId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "clientTokenId": 12345,
      "isEnabled": true
    },
    "scheduling": {
      "timeframes": [
        {
          "day": 1,
          "from": "07:00",
          "to": "16:00"
        }
      ],
      "timezone": "America/New_York"
    },
    "tick_every": "integer"
  },
  "public_id": "string",
  "status": "live",
  "steps": [
    {
      "allowFailure": false,
      "alwaysExecute": false,
      "exitIfSucceed": false,
      "isCritical": false,
      "name": "string",
      "noScreenshot": false,
      "params": {},
      "public_id": "string",
      "timeout": "integer",
      "type": "assertElementContent"
    }
  ],
  "subtype": "http",
  "tags": [],
  "type": "string"
}
```
{% /tab %}
{% /tabs %}
{% /tab %}

{% tab label="400" %}
- JSON format is wrong
- Creation failed

{% tabs %}
{% tab label="Model" %}
Error response object.

| Field               | Type     | Description                          |
| ------------------- | -------- | ------------------------------------ |
| errors [*required*] | [string] | Array of errors returned by the API. |
{% /tab %}

{% tab label="Example" %}
```json
{
  "errors": [
    "Bad Request"
  ]
}
```
{% /tab %}
{% /tabs %}
{% /tab %}

{% tab label="402" %}
Test quota is reached

{% tabs %}
{% tab label="Model" %}
Error response object.

| Field               | Type     | Description                          |
| ------------------- | -------- | ------------------------------------ |
| errors [*required*] | [string] | Array of errors returned by the API. |
{% /tab %}

{% tab label="Example" %}
```json
{
  "errors": [
    "Bad Request"
  ]
}
```
{% /tab %}
{% /tabs %}
{% /tab %}

{% tab label="403" %}
Forbidden

{% tabs %}
{% tab label="Model" %}
Error response object.

| Field               | Type     | Description                          |
| ------------------- | -------- | ------------------------------------ |
| errors [*required*] | [string] | Array of errors returned by the API. |
{% /tab %}

{% tab label="Example" %}
```json
{
  "errors": [
    "Bad Request"
  ]
}
```
{% /tab %}
{% /tabs %}
{% /tab %}

{% tab label="429" %}
Too many requests

{% tabs %}
{% tab label="Model" %}
Error response object.

| Field               | Type     | Description                          |
| ------------------- | -------- | ------------------------------------ |
| errors [*required*] | [string] | Array of errors returned by the API. |
{% /tab %}

{% tab label="Example" %}
```json
{
  "errors": [
    "Bad Request"
  ]
}
```
{% /tab %}
{% /tabs %}
{% /tab %}
{% /tabs %}

### Code Example

{% tabs %}
{% tab label="Curl" %}
```bash
# Set your Datadog site and credentials
export DD_SITE="datadoghq.com" # Or us3.datadoghq.com, us5.datadoghq.com, datadoghq.eu, ap1.datadoghq.com, ap2.datadoghq.com, uk1.datadoghq.com, ddog-gov.com, us2.ddog-gov.com
# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

curl -X POST "https://api.${DD_SITE}/api/v1/synthetics/tests" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "config": {
    "assertions": [
      {
        "operator": "is",
        "target": 200,
        "type": "statusCode"
      }
    ],
    "request": {
      "method": "GET",
      "url": "https://example.com"
    }
  },
  "locations": [
    "aws:eu-west-3"
  ],
  "message": "Notification message",
  "name": "Example API test",
  "options": {
    "tick_every": 60
  },
  "status": "live",
  "type": "api"
}
EOF
```
{% /tab %}
{% /tabs %}
