Self-hosted · Open Source · Enterprise Ready

Orchestrate your
API tests at scale

Build, chain, validate, and schedule API tests with intelligent dependency resolution, infrastructure verification, and real-time streaming results. All self-hosted, all yours.

OrchestAPI — Run Results
User Checkout Flow SUCCESS
836ms
POST Auth Token 200 142ms
GET Get Products 200 89ms
POST Add to Cart 201 201ms
POST Checkout running...
GET Verify DB waiting
3 of 5 steps complete ● Live
9
Infrastructure Connectors
5
HTTP Methods Supported
4
Validation Types
Step Dependencies

Everything you need for
enterprise API testing

A complete orchestration platform that goes beyond simple request-response testing.

HTTP API Testing

Full support for GET, POST, PUT, DELETE, PATCH with headers, query params, request bodies, and curl import.

Step Dependencies

DAG-based dependency resolution with intelligent caching, TTL management, and automatic execution ordering.

Response Validation

Validate headers, exact body matches, field-level assertions, and data type checks across 10+ operators.

Infrastructure Verification

Verify database state, message queues, and caches after API execution with 9 built-in connectors.

Cron Scheduling

Schedule recurring test runs with cron expressions. Non-interactive execution with sensible defaults.

Variable Extraction

Extract values from responses via JSON path, inject them into subsequent steps with ${VAR} and {{step.path}} syntax.

Live Streaming

Watch test execution in real-time via Server-Sent Events. See each step pass, fail, or require input as it happens.

Response Handlers

Configure per-status-code actions: SUCCESS, ERROR, FIRE_SIDE_EFFECT, RETRY — with automatic retry logic.

Environment Management

Variables with secrets, default headers, file uploads, and infrastructure connectors — all managed per environment.

Mock Server

Create mock API endpoints with configurable responses, path matching, match rules, and request logging — all standalone.

Webhook Tester

Receive and inspect incoming HTTP requests in real-time via SSE. Supports binary, multipart, file preview and download.

Response Validation

Validate response headers, body fields, exact/flexible/structural JSON matching, and data types per step.

Intuitive tabbed editor,
orchestrator-grade power

Build API test steps with a familiar tabbed interface. Import from curl, configure headers, query parameters, and request bodies across all HTTP methods. Each step is a composable building block in your test suite.

GET POST PUT DELETE PATCH
  • Tabbed editor with Headers, Params, Body, Dependencies, Handlers, Variables, and Verifications
  • Curl import — paste a curl command and auto-populate all fields
  • Default environment headers with per-step override capability
  • Dynamic placeholders: ${VAR} for environment, {{step.path}} for step data, #{name} for manual input
Headers Params Body Deps Handlers
POST ${baseUrl}/api/v1/checkout
KEYVALUE
Authorization Bearer {{auth.token}}
Content-Type application/json
X-Request-Id ${requestId}

Intelligent dependency
resolution engine

Chain API steps into complex workflows using a DAG-based execution engine. Steps automatically resolve in the correct order, with built-in caching to avoid redundant calls and TTL management for freshness guarantees.

  • Directed Acyclic Graph (DAG) resolution — steps execute in topological order
  • Per-step caching with configurable TTL — avoid redundant API calls within a run
  • Dependency-only steps — execute only when needed by other steps, skipped in suite runs
  • Manual input reuse across dependent steps via #{name} placeholder sharing
1. Auth Token 142ms ✓
↓ depends on
2. Get Products 89ms ✓
↓ depends on 1 & 2
3. Add to Cart running...
↓ depends on 3
4. Checkout waiting
↓ depends on 4
5. Verify Order DB waiting

Multi-layered response
validation system

Go beyond status code checks. Validate headers, match entire response bodies, assert specific field values, and verify data types — all with flexible matching modes that adapt to your testing needs.

  • 10+ assertion operators: equals, contains, regex, greater than, less than, exists, and more
  • Three match modes: Strict (exact), Flexible (subset), Structure (shape only)
  • JSON path support for deep field access: $.data.orders[0].total

Header Validation

Assert response headers match expected values — content types, cache controls, auth tokens.

Body Exact Match

Compare the entire response body against an expected payload with strict, flexible, or structure matching.

Body Field Assert

Target specific fields via JSON path and apply assertion operators — equals, contains, regex, numeric comparisons.

Body Data Type

Verify field types are STRING, NUMBER, BOOLEAN, ARRAY, OBJECT, or NULL at any JSON path.

Verify the entire stack,
not just the API

After an API call, verify that the right data landed in the right place. Connect to databases, message queues, and caches to run post-execution assertions.

PG
PostgreSQL
MY
MySQL
OR
Oracle
MS
SQL Server
RD
Redis
ES
Elasticsearch
KF
Kafka
RB
RabbitMQ
MG
MongoDB
Verification Results
4/4 PASSED
PG Check order record exists
$.rowCount EQUALS 1
$.rows[0].status EQUALS "confirmed"
KF Verify event published pre-listen
$.value.eventType CONTAINS "ORDER_CREATED"
$.value.orderId EXISTS

From setup to execution
in four steps

1

Configure Environment

Set base URLs, variables, secrets, default headers, and infrastructure connectors for each environment.

2

Build Test Suite

Create steps with the tabbed editor. Import from curl, define dependencies, add handlers and validations.

3

Execute & Stream

Run individual steps or full suites. Watch results stream in real-time via SSE with live status updates.

4

Schedule & Monitor

Set up cron schedules for automated runs. Monitor pass rates, review history, and export results.

Built on proven,
battle-tested tech

Modern stack, zero vendor lock-in. Deploy on your own infrastructure with full control.

Java 21

Spring Boot 3.3.7

React 19

TypeScript + Vite

🐘

PostgreSQL

Flyway Migrations

🔫

Docker

Single Image Deploy

Comprehensive docs to
get you running fast

Environment Setup

  • Create environments with base URLs
  • Add variables (static, UUID, timestamp)
  • Configure default headers
  • Set up infrastructure connectors
  • Import/export as JSON

Test Suite Builder

  • Create steps with all HTTP methods
  • Import from curl commands
  • Define step dependencies (DAG)
  • Configure response handlers
  • Add response validations

Execution & Results

  • Run single steps or full suites
  • Stream results in real-time (SSE)
  • Schedule cron-based automated runs
  • Review run history with filters
  • Export results as JSON

Up and running in minutes

Clone, configure, and launch. OrchestAPI ships as a single Docker image with PostgreSQL as the only dependency.

# 1. Pull the image
docker pull santhoshkumr96/orchestapi:latest

# 2. Start with PostgreSQL
docker run -d \
  --name orchestapi \
  -p 8080:8080 \
  -e DB_HOST=your-postgres-host \
  -e DB_NAME=orchestapi \
  -e DB_USER=your-user \
  -e DB_PASS=your-password \
  santhoshkumr96/orchestapi:latest

# 3. Open http://localhost:8080

# Deploy behind a reverse proxy / Kubernetes Ingress?
# Set CONTEXT_PATH and build with VITE_BASE_PATH:
docker build --build-arg VITE_BASE_PATH=/orchestapi -t orchestapi .
docker run -e CONTEXT_PATH=/orchestapi ...

Ready to orchestrate
your API tests?

Deploy OrchestAPI on your infrastructure and take control of your API testing workflow.