Pre/Post Processors in Apidog

Pre and post-processors are a key feature in Apidog. When you send a request, you can use pre-processors to dynamically control your request, or use post-processors to handle the received response.

Apidog provides a visual, drag-and-drop interface for pre and post-request operations, complementing traditional script-based approaches. This visual interface allows you to configure common operations without writing code, while still supporting custom scripts for advanced use cases.

Quick Start

Here are the steps to use pre and post-processors in Apidog:

Open any endpoint and navigate to the Run tab (Design-first Mode) or Request tab (Request-first mode).

Design-first Mode

Request-first Mode

Switch to the Pre Processors or Post Processors section, hover over + Add, and select the desired processor.

Fill in the necessary fields for the added processor.

Click Send, and the request will execute with the configured pre/post processors.

In Design-first Mode, click Save as case to save the request. In Request-first Mode, click Save or Save as case to save the request.

Design-first Mode

Request-first Mode

TIP

You can also create a standalone request and apply pre/post-processors to it. However, we recommend leveraging pre/post-processors on top of the endpoint specification to make debugging and testing more streamlined.

Capabilities

Pre and post processors can collectively achieve various functionalities:

Pre Processors

Request Parameter Setup: Dynamically define input data for the API endpoint.

Header Configuration: Specify headers such as Content-Type, Accept, and Authorization.

Authentication: Add tokens, API keys, or credentials for protected endpoints.

Database Integration: Retrieve values from a database to use as request parameters.

Encryption: Secure the request payload before transmission.

Post Processors

Assertions: Validate the received response against expected results (status codes, body content, etc.).

Variable Extraction: Extract values from the response to use in subsequent requests.

Database Operations: Write response data to a database for storage or updating.

Data Visualization: Generate reports or visual representations of the response data.

Available Processors

Apidog supports the following pre/post processors:

Processor	Type	Description
Assertion	Post	Define validation rules to check response data against expected values (status code, body, headers).
Extract Variable	Post	Extract values from the response (JSON, XML, Text) and store them as variables using JSONPath or XPath.
Database Operation	Pre/Post	Connect to SQL/NoSQL databases to execute queries. Results can be stored as variables.
Custom Scripts	Pre/Post	Write custom JavaScript code to handle complex logic. Access request/response data and environment variables.
Public Scripts	Pre/Post	Create reusable script snippets shared across multiple processors or scenarios.
Wait	Pre/Post	Introduce a delay before or after a request, useful for simulating real-world latency.

We recommend using the Apidog Script Generator to simplify script writing. Describe your logic in natural language, and the generator will create a runnable script for you.

Execution Order

Pre and post-processors can be configured at multiple levels:

Run/Endpoint Case Level (Default): Affects only the current run/case.

Endpoint Level: Applies to all cases associated with the endpoint.

Folder Level: Impacts all endpoints within the folder.

Project Level: Applies to all requests within the project (highest scope).

The execution flows from the highest level (Project/Folder) down to the specific Run/Case level.

Visualizing Execution

A set of pre-processors in a request may look like this:

In the screenshot above:

The first three processors are grouped under Inherit from parent. They are defined in the Root folder, specific folders (e.g., "Pets"), or the endpoint itself.

These inherited processors are read-only in the current run but can be toggled on/off.

The last processor is a custom script added specifically for this run and can be edited directly.

Variable Substitution

You may notice a step called Variable Substitution & Inherit from Parents. This special pre-processor replaces placeholders like {{variable}} with their actual values.

Default Behavior: Most pre-processors execute before variable substitution.

Post-Substitution: Some scripts (e.g., API signing) must run after variables are replaced. You can manually drag these processors below the "Variable Substitution" step.

Complete Execution Flow

The detailed execution order for a single request is as follows:

Pre/Post Processors in Apidog

Quick Start#

Capabilities#

Pre Processors#

Post Processors#

Available Processors#

Execution Order#

Visualizing Execution#

Variable Substitution#

Complete Execution Flow#

Quick Start

Capabilities

Pre Processors

Post Processors

Available Processors

Execution Order

Visualizing Execution

Variable Substitution

Complete Execution Flow