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.

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

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

Parameter Sources

Each parameter row has a Key, a source dropdown, and a value field. The source decides where the value comes from each time the action runs:

Fixed Value

Static values that never change.

A fixed value can also contain placeholders such as Bearer {{var.API_KEY}} or {{system.session_id}}. Chipp replaces them when the action runs.

A fixed value is always sent as text. 10 is sent as the string "10", not the number 10.

Use for: API versions, static identifiers, constant headers

AI Fills It In

Dynamic values the AI decides from the conversation.

An AI-filled parameter has three more settings. See Type, Required, and Sample Value below.

Use for: Search queries, dynamic filters, contextual values

Application Variable

Reusable values defined once per application, in the Variables tab.

You can also type {{var.API_KEY}} into a fixed value, which is useful when the variable is only part of the text (for example Bearer {{var.API_KEY}}).

Use for: API keys, base URLs, workspace IDs

System Variable

Platform-provided runtime values. Pick one from the list:

See Variables and Secrets for details, and for {{system.query.NAME}}, which you type into a fixed value.

Use for: User context, audit trails

Output from Another Action

Use a value from an action that already ran in the same conversation. This chains actions into a multi-step workflow: one API call’s result feeds the next.

Configuration fields:

How it works:

1. The first action runs in the conversation and Chipp stores its result for 30 minutes.
2. When the AI calls the second action, Chipp reads that stored result and applies your JSONPath.
3. The selected value goes into the parameter. In a body parameter it keeps its JSON type (a number stays a number, a list stays a list). In a header, query, or path parameter it becomes text, and objects and lists become JSON text.
4. If the first action has not run yet in this conversation, the call stops and the AI is told to run the first action and then try again.
5. If your JSONPath finds nothing in the result (for example an empty search), the call stops and the AI is told why, so it can tell the user.

The AI does not fill in a chained parameter, and it does not see one in the action’s inputs.

Supported JSONPath:

$                  The whole output
$.id               Top-level field: {"id": "123"} -> "123"
$.data.user.email  Nested field: {"data": {"user": {"email": "a@b.com"}}} -> "a@b.com"
$['first name']    A field name with spaces or symbols
$.items[0].name    First array item: {"items": [{"name": "First"}]} -> "First"
$.items[-1].name   Last array item
$.items[*].id      Every item: {"items": [{"id": 1}, {"id": 2}]} -> [1, 2]
$.data.*           Every value of an object, as a list

A JSONPath must start with $. Filters ([?(...)]), slices ([0:2]), recursive descent (..), and unions ([0,1]) are not supported. The editor and the server both reject them when you save, so a selector can never silently match nothing.

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"

Tips:

• Save the first action before you configure the second one. The action list only shows saved actions.
• Describe both actions clearly, so the AI knows to run the first one before the second one.
• If the first action is deleted, the chained parameter shows a warning. Pick another action.

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

Type, Required, and Sample Value

These settings appear on every AI fills it in parameter. They shape the input description the AI receives for the action.

Type

Chipp checks the AI’s value against the type before it calls your API. A value that does not match (for example "abc" for a number) is rejected, and the AI is asked to correct it, so your API never receives it.

Type applies to AI-filled values. Fixed values are always sent as text.

Required

• Required: The AI must provide the value before it can run the action. A required text, list, or object value cannot be empty.
• Not required: The AI includes the value only when it is relevant. A missing optional value is left out of the request.

A path parameter is required unless you turn it off, because an empty path segment breaks the URL.

Sample Value

A sample shows the AI the format you expect. Chipp adds it to the parameter’s description for the AI, and Test Request sends it in place of a real AI value.

Writing Effective Instructions

Good Example:

Generate a professional email subject line (max 100 chars) based on the email content. Include the recipient's name if mentioned.

Bad Example:

Make a subject

Advanced Patterns

Nested Body Fields

Body parameters are sent as top-level JSON keys, exactly as you write them. A key with dots stays one flat key: response_format.type is sent as {"response_format.type": "..."}, not as a nested object.

To send a nested object, add one parameter for the top-level key (for example response_format), set its source to AI fills it in, set Type to Object, and describe the shape in the instructions. A chained parameter (Output from another action) can also carry an object or a list from an earlier action’s result.

Mixed Sources

One action can combine every source:

Optional Parameters

Turn Required off and say when to include the value in the instructions, for example “Include only if the user names a category”. The AI leaves the parameter out when it does not apply.

Testing Parameters

1. Use the Built-in Tester

Test Request sends a real request with your parameters resolved:

URL: https://api.example.com/search
Query: q = AI fills it in (sample value "john")

GET https://api.example.com/search?q=john

2. Verify Variable Resolution

Check what each source sends during a test:

• Fixed values and application variables send their real values
• {{system.timestamp}} sends the current time; every other system variable sends a placeholder, because a test has no chat
• AI-filled parameters send their sample value, or a placeholder such as <q> when there is no sample
• Chained parameters (Output from another action) send their test value, or a placeholder such as <org_id>, because a test has no earlier action output

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 →