Parameter Configuration

Parameter Types

Headers

HTTP headers sent with your request.

{
  "Authorization": "Bearer {{var.API_KEY}}",
  "Content-Type": "application/json",
  "X-User-ID": "{{system.user_id}}"
}

Query Parameters

URL parameters appended to your endpoint.

GET https://api.example.com/search?q={{query}}&limit=10&page={{page}}

Body Parameters

JSON data sent in POST, PUT, and PATCH requests.

{
  "name": "{{userName}}",
  "email": "{{userEmail}}",
  "metadata": {
    "source": "chipp",
    "timestamp": "{{system.timestamp}}"
  }
}

Path Parameters

Dynamic URL segments replaced at runtime.

# URL Template
https://api.example.com/users/{{userId}}/posts/{{postId}}

# Result
https://api.example.com/users/123/posts/456

Parameter Sources

Fixed Value

Static values that never change.

Use for: API versions, static identifiers, constant headers

Let AI Generate

Dynamic values determined by AI based on context.

Use for: Search queries, dynamic filters, contextual values

System Variables

Platform-provided runtime values.

Use for: User context, audit trails, conversation analysis

Application Variables

Reusable values defined at the application level.

Use for: API keys, base URLs, workspace IDs

Output from Another Action

Use results from previously executed actions as inputs for subsequent actions. This creates powerful multi-step workflows where data flows between API calls.

Configuration Fields:

How it works:

1. The prerequisite action runs first and returns data
2. The JSONPath selector extracts the needed value (or uses full response if blank)
3. The extracted value replaces the parameter in your current action
4. If the prerequisite hasn't run yet, the AI automatically runs it first

JSONPath Examples:

$.id                    // Top-level field: {"id": "123"} → "123"
$.data.user.email       // Nested field: {"data": {"user": {"email": "a@b.com"}}} → "a@b.com"
$.items[0].name         // First array item: {"items": [{"name": "First"}]} → "First"
$.items[*].id           // All IDs: {"items": [{"id": 1}, {"id": 2}]} → [1, 2]
$.data.users[?(@.active)] // Filtered: active users only

Real-World Example:

Scenario: Create a support ticket for a user's organization

Action 1: Get User Details

• Returns: {"user": {"id": "u123", "org_id": "org456", "name": "John"}}

Action 2: Create Ticket

• Parameter: organization_id
• Source: Output from another Action
• Action: Get User Details
• JSONPath: $.user.org_id
• Result: Parameter receives "org456"

Important: JSONPath is Optional

You have two options for extracting data:

1. With JSONPath (precise): Specify exact path like $.data.id to extract a specific value
2. Without JSONPath (AI-powered): Leave blank and use the Context field to describe what you need. The AI will intelligently find and use the right value from the response.

Example without JSONPath:

• Action returns: {"user": {"id": "123", "email": "john@example.com"}, "org": {"id": "456"}}
• Context: "Use the organization ID from the response"
• Result: AI extracts "456" automatically

Tips:

• JSONPath is optional - the Context field alone often works perfectly
• Test JSONPath at jsonpath.com with sample data if you need precision
• Actions with dependencies show a link icon in your action list
• The AI is smart about finding the right values based on your context description

Use for: Multi-step workflows, data enrichment, sequential API operations

Data Types

String

Text values, URLs, identifiers.

{
  "name": "John Doe",
  "url": "https://example.com"
}

Number

Integers and decimals.

{
  "count": 42,
  "price": 19.99
}

Boolean

True/false values.

{
  "active": true,
  "verified": false
}

Object

Nested JSON structures.

{
  "metadata": {
    "tags": ["important", "urgent"],
    "properties": {
      "color": "blue"
    }
  }
}

Array

Lists of values.

{
  "tags": ["api", "integration", "automation"],
  "ids": [1, 2, 3]
}

AI Generation Guidelines

Writing Effective Instructions

Good Example:

Bad Example:

Providing Sample Values

Sample values teach the AI about format expectations:

Required vs Optional

• Required: AI must provide a value or the action fails
• Optional: AI includes only when relevant

Advanced Patterns

Nested Parameters

Configure complex JSON structures:

# Flat parameter keys
response_format.type = "json_schema"
response_format.json_schema.strict = true
response_format.json_schema.name = "analyze"

# Resulting JSON
{
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "strict": true,
      "name": "analyze"
    }
  }
}

Mixed Sources

Combine different parameter sources:

{
  "api_key": "{{var.API_KEY}}", // Variable
  "user_id": "{{system.user_id}}", // System
  "query": "{{searchTerm}}", // AI generated
  "limit": 10, // Fixed
  "org_id": "{{previousAction.org_id}}" // Dependency
}

Conditional Parameters

AI determines whether to include optional parameters:

{
  "filter": {
    "source": "Let AI generate",
    "required": false,
    "instructions": "Include only if user specifies filtering criteria"
  }
}

Testing Parameters

1. Use the Built-in Tester

Preview how parameters resolve:

# Configuration
URL: https://api.example.com/{{endpoint}}
Query: search={{query}}

# Test Values
endpoint: "users"
query: "john"

# Result
GET https://api.example.com/users?search=john

2. Verify Variable Resolution

Check that all variables resolve correctly:

• Application variables show actual values
• System variables show placeholders
• AI parameters show example values

3. Test Edge Cases

• Empty optional parameters
• Special characters in values
• Large nested objects
• Array parameters

Next Steps

• Manage Variables →
• Test Your Actions →
• View Examples →