Skip to main content

Conduit Steps Reference

Reference documentation for all step types available in Conduits.

Step Types​

Request Step​

Execute an HTTP request.

Configuration:

  • Request (select existing or create new)
  • Extractions (pull data from response)
  • Assertions (validate response)
  • Continue on failure (optional)

Use for: API calls, data fetching, resource manipulation

Learn more →

Delay Step​

Pause execution for a specified duration.

Configuration:

  • Duration (milliseconds)

Use for: Rate limiting, waiting for async operations, database propagation

Example:

Delay 1000ms

Variable Step​

Set or modify variables during execution.

Configuration:

  • Variable name
  • Variable value (can use other variables)

Use for: Computing values, setting defaults, transforming data

Example:

Set fullName to "{{firstName}} {{lastName}}"
Set retryCount to 3

Assertion Step​

Standalone validation without a request.

Configuration:

  • Condition to evaluate
  • Failure action (stop/continue)

Use for: Validating prerequisites, checking variable values, conditional logic

Script Step​

Execute custom JavaScript for complex logic.

Configuration:

  • JavaScript code
  • Input variables
  • Output variables

Use for: Complex transformations, calculations, custom validation

Loop Step​

Repeat a set of steps multiple times.

Types:

  • For Each: Iterate over array
  • While: Repeat until condition
  • For: Fixed number of iterations

Configuration:

  • Loop type
  • Condition/array/count
  • Child steps to repeat

Use for: Bulk operations, polling, data-driven testing

Conditional Step​

Execute steps based on conditions.

Configuration:

  • Condition expression
  • Steps to run if true
  • Steps to run if false (optional)

Use for: Branching logic, error handling, environment-specific behavior

Step Properties​

Common Properties​

All steps have:

  • Name: Display name for the step
  • Description: Optional explanation
  • Enabled: Can disable without deleting
  • Continue on Failure: Keep going if step fails

Step Execution Order​

Steps execute sequentially by default:

1. Login Request
2. Extract token
3. Delay 500ms
4. Get User Request
5. Assert user data valid

Step Dependencies​

Steps can depend on previous steps:

  • Access extracted variables from earlier steps
  • Conditional execution based on earlier results
  • Skip steps if prerequisites fail

Request Step Details​

Extractions​

Pull data from responses:

From: Response Body
Path: data.userId
Save As: userId

Multiple extractions per step allowed.

Learn more →

Assertions​

Validate responses:

Status Code equals 200
Field "status" equals "success"
Response time less than 500

Multiple assertions per step allowed.

Learn more →

Authentication​

Request steps inherit auth from:

  1. Request configuration
  2. Collection default
  3. Environment settings

Variable Step Details​

Setting Variables​

Name: calculatedTotal
Value: {{price}} * {{quantity}}

(If expressions are supported)

String Manipulation​

Name: fullUrl
Value: {{baseUrl}}/users/{{userId}}

Type Conversion​

Variables are dynamically typed based on value.

Delay Step Details​

Fixed Delay​

Duration: 1000

Waits exactly 1 second.

Variable Delay​

Duration: {{delayMs}}

Use variable for dynamic delays.

Use Cases​

  • Rate Limiting: Respect API rate limits
  • Async Operations: Wait for background jobs
  • Database Replication: Allow data propagation
  • Testing Timeouts: Verify timeout handling

Loop Step Details​

For Each Loop​

Iterate over array:

For Each item in {{usersList}}:
  - GET /users/{{item.id}}
  - Assert status 200

While Loop​

Repeat until condition:

While {{retryCount}} > 0:
  - Try request
  - Decrement retryCount

For Loop​

Fixed iterations:

For i from 1 to 10:
  - Create user {{i}}

Script Step Details​

Execute custom JavaScript logic.

Available APIs​

// Access variables
const userId = vars.get('userId');

// Set variables
vars.set('processedData', result);

// Make calculations
const total = price * quantity;

// String manipulation
const formatted = `User: ${userId}`;

// Return value
return total;

Best Practices​

  • Keep scripts simple
  • Use request steps when possible
  • Document complex logic
  • Handle errors gracefully

Best Practices​

Step Organization​

  • Use descriptive step names
  • Group related steps logically
  • Add comments/descriptions
  • Keep steps focused (single responsibility)

Error Handling​

  • Add assertions to validate assumptions
  • Use "Continue on Failure" strategically
  • Clean up resources even on failure
  • Log/export results for debugging

Performance​

  • Minimize unnecessary delays
  • Use parallel execution when possible (if supported)
  • Cache reusable data
  • Limit loop iterations

Maintainability​

  • Extract common flows to separate conduits
  • Use variables instead of hardcoding
  • Document non-obvious logic
  • Review and refactor periodically

See Also​