EchoAPI’s Powerful Dynamic Values & Custom Functions

Dynamic values and custom functions are key features in EchoAPI that streamline API testing and adapt to complex business logic.
They shine in multi-step workflows, parameter dependencies, and cases requiring flexibility.
Let’s break it down with real-world scenarios.

Dynamic Values: Handle Parameters That Change With Context

Dynamic values are parameters automatically generated or retrieved in real time (e.g., timestamps, random numbers, values from previous responses).
They solve two core problems: parameters that change constantly and dependencies between APIs.

Example: E-commerce Checkout Flow (Cross-API Dependency)

A US-based e-commerce developer needs to debug the chain: Create Order → Make Payment

1. Create Order API:

returns a unique orderId (new each time).

Save the returned orderId into env variables

Add Post-response → Extract Variables

Send request → see random output

Pick a function → Insert

Click Mock data function

2. Payment API:

requires the orderId from the previous step, plus:

• timestamp (to avoid expired requests)
• nonce (to prevent replay attacks)

How to Apply Dynamic Values

1. After calling Create Order, use EchoAPI’s Post-response → Extract Variables to auto-extract orderId and store it in the environment.

2. When calling Payment API, select dynamic values in parameters:

• orderId: Reference Env → orderId
• timestamp: Add Dynamic Value → Mokc Data → Date (auto-generated in ms)
• nonce: Add Dynamic Value → Mokc Data → Random String (auto-generated, valid format)

Key Benefits

1. No copy-paste errors: No need to manually copy IDs or calculate timestamps. Avoids typos that break requests.
2. Faster debugging: Multi-API chains that used to take 5 minutes manually can now be done in under 1 minute.
3. Time zone ready: Auto-generate UTC and regional times (JST, PST, WIB, etc.) without manual conversion — perfect for global testing.

Built-In System Dynamic Values

EchoAPI comes with ready-to-use dynamic values that don’t require any setup.
They generate data on the fly and cover the most common needs for API testing.

Time-Based Dynamic Values

Time values are among the most frequently used. Perfect for APIs that require timestamps or date-based validation. Built-in support for multiple time zones.

Advantage: No manual time-zone math. Critical for global APIs where accuracy across regions matters.

Random Dynamic Values

Random values generate unpredictable data, commonly used for replay-attack prevention and test data generation.

Advantage: Define rules to generate realistic test data — no need to craft it manually.

Environment Info Dynamic Values

These values pull information from the current test environment, useful for identifying request sources or context.

Advantage: Auto-fills environment data without manual lookup, ensuring accuracy.

Constants & Format Dynamic Values

Provides commonly used constants and format helpers to simplify parameter setup.

Advantage: Standardized constants prevent formatting errors in requests.

Key Features of Built-in Dynamic Values

1. Ready to use — no setup, works out of the box
2. Real-time — generated fresh for each request
3. Offline support — works without internet, fully local
4. Cross-platform — same behavior in EchoAPI desktop, VS Code, and IDEA plugins
5. Composable — can be combined with other dynamic values or custom functions

Example: generate an order ID with a timestamp prefix + UUID

ORDER_{{$fakerjs.Date.birthdate|format(YYYY/MM/DD HH:mm:ss,+08:00)}}{{$fakerjs.String.uuid}}  

Built-in dynamic values cover the most common needs in API testing. They make handling time-related parameters, random test data, and environment identifiers effortless — cutting manual input and reducing errors, while boosting efficiency.

Custom Functions: Solving the Pain Point of “Custom Logic”

Custom functions allow developers to write scripts (e.g., parameter encryption, special formatting, custom validation) tailored to their business rules.
They address cases where built-in features aren’t enough. Common scripting languages like JavaScript are supported.

Example: Fintech API Parameter Encryption (Custom Logic)

A fintech developer is debugging a “Bind Card API” where the requirements are:

1. Sensitive parameters (e.g., phone number phone) must be encrypted with MD5 (custom platform rule, not a generic standard).

2. The encrypted value must then be prefixed with IDN_FIN_ (a business identifier) before being sent as a request parameter.

How to Apply a Custom Function

1. In EchoAPI’s Custom Function module, write an encryption script:

try {
    // JavaScript does not have native MD5 support.
    // This is a simplified mock (real MD5 is more complex).
    let hash = 0;
    if (text.length === 0) return hash.toString(16);
    for (let i = 0; i < text.length; i++) {
        let char = text.charCodeAt(i);
        hash = ((hash << 5) - hash) + char;
        hash = hash & hash; // Convert to 32-bit integer
    }
    return hash.toString(16);
} catch (e) {
    return text;
}

Reference the custom function in parameter values

Enter your script and test the result

Click Create

Select Custom Function Management

Click Functions

2. When calling the Bind Card API, in the phone parameter select:

→ Custom Function → MD5Encrypt
→ Enter raw value → EchoAPI will auto-encrypt and add the prefix.

Key Advantages

1. Custom business rules: Handle unique encryption rules (prefixes, non-standard algorithms) without external tools.
2. Lower technical overhead: No need to set up a local crypto environment — write, debug, and reuse scripts directly inside EchoAPI.
3. Compliance across regions: Easily adapt to region-specific requirements (e.g., Indonesia fintech prefix, US payment validation) without switching tools.

Built-in Custom Functions in EchoAPI

EchoAPI also provides a set of built-in functions, ready to use without writing code.
They cover common needs like string handling, data conversion, and encoding/decoding.
Combined with dynamic values, they dramatically speed up parameter handling.

1. String Functions

String functions handle text transformation and formatting — ensuring parameters meet API requirements.

Example Use Case: Normalize product IDs for a US e-commerce site by converting to uppercase and padding zeros.

2. Data Conversion Functions

These handle type conversions and data standardization.

Regional Adaptation: formatDate supports different locale formats, e.g.:

• Japan → "YYYY年MM月DD日"
• Indonesia → "DD/MM/YYYY"

3. Encryption & Encoding Functions

Provide common encryption algorithms and encoding methods to meet API security requirements.

Typical Use Case: Apply HMAC-SHA256 encryption to request parameters of an Indonesian finance API to ensure secure transmission.

4. Math & Logic Functions

Provide mathematical operations and logical conditions to support dynamic parameter calculations.

Typical Use Case: Calculate sales tax for US e-commerce orders (amount × taxRate), then round to two decimals.

5. System Utility Functions

Provide utilities related to the system environment.

Practical Use Case: Set environment variables before an API request, or insert debug logs in complex flows.

6. Key Features of Built-in System Functions

1. Zero Configuration: All system functions are pre-built, ready to use without extra setup.
2. Cross-Platform Consistency: Behave the same across EchoAPI main program and plugins.

Composable: Functions can be nested to form complex logic.

// Example: Generate a signature with timestamp
try {
  const timestamp = new Date().getTime();
  const signature = `${text}-${timestamp}`;
  return signature;
} catch (error) {
  return text;
}

1. Offline Available: All functions execute locally without internet.
2. Regional Adaptation: Some functions (e.g., date handling) are optimized for regional formats.

System functions cover 80% of common API debugging needs. Together with dynamic values, they eliminate most manual scripting, making them ideal for fast testing and standardized parameter handling.

Summary: Core Value of Dynamic Values & Custom Functions

Together, they let developers focus on business validation rather than parameter handling, reducing repetitive work and minimizing human error. By leveraging dynamic values and custom functions, teams can quickly adapt to different API structures, localization requirements, and compliance rules, ensuring smoother integration across multiple regions.