API Tree (Response Tree)

The API Tree (Response Tree) is a visual representation of an API response structure. It allows you to browse, explore, and select exact JSON paths from real responses without writing them manually.

Instead of guessing JSON paths, you select them directly from a structured tree.

Why it matters

• Precision: Avoid broken JSON paths and typing errors.
• Speed: Select values in seconds instead of inspecting raw JSON manually.
• Powerful comparisons: Extract exact fields from complex nested responses.
• Dynamic validation: Compare real runtime data between APIs.

When to use it

• You want to extract a specific field from an API response.
• You need to compare nested values inside arrays or objects.
• You are using Expected API and need a reliable reference path.
• The response contains deeply nested JSON.

Core concepts

• Response Tree – hierarchical view of JSON structure.
• Node – a single field inside the response.
• Path – the full JSON path to a specific value.
• Root Source – determines which response is being explored.

How it works

1. The API executes.
2. The system receives the JSON response.
3. The JSON is converted into a navigable tree.
4. You expand nodes and select the exact field you want.
5. The selected path is automatically inserted into the comparison field.

Understanding Tree Roots

The root determines which response you are browsing.

last_response

Represents the response of the Action API.

Example:

{
  "user": {
    "id": 15,
    "email": "john@email.com",
    "balance": 250
  }
}

Selecting balance generates a path like:

last_response.user.balance

expected

Represents the response of the Expected API.

Used when comparing two APIs.

Example:

expected.user.balance

multi_responses

Represents repeated executions (when list parameters trigger multiple runs).

Example:

If the API runs 3 times due to an array input:

multi_responses[0].user.id
multi_responses[1].user.id
multi_responses[2].user.id

This allows validation across batch executions.

Working with Arrays

{
  "users": [
    {"id": 1, "role": "admin"},
    {"id": 2, "role": "user"}
  ]
}

last_response.users[0].id
last_response.users[1].role

• A specific index
• Or use comparison logic to check values dynamically

Selecting the Correct Path

When using the API Tree:

• Expand nodes gradually.
• Select the leaf value (not the parent object).
• Always verify the path corresponds to a value, not an entire object.

Common Patterns

Validate the existence

last_response.user.id

Validate numeric range

last_response.user.balance

Best practices

• Always test the API before using the tree.
• Select the smallest meaningful value (avoid comparing full objects).
• Use Expected API when validating dynamic backend state.
• For arrays, validate specific indices only when order matters.

Common mistakes

❌ Selecting the parent object instead of a value
✔ Always select the final leaf node.

❌ Hardcoding full JSON instead of using tree paths
✔ Use tree selection for maintainable validation.

❌ Ignoring multi_responses when using array inputs
✔ Use indexed paths for repeated executions.

Security & permissions

• Tree data is generated from executed API responses.
• Only users with execution permission can preview tree data.
• Sensitive authentication data is never exposed in the tree.

Related documentation

• Action API vs Expected API
• Comparison Types
• Parameters in Depth
• Running a Test Case