Skip to content
Reqloom
A request dependency graph with one resolved execution chain highlighted.

Your API is a graph.
Test it like one.

Define each actor and resource once. Run any endpoint and Reqloom resolves the prerequisite chain for you — in order, with the right credentials.
Take the 5-minute tour Read the mental model GitHub

The problem

Six requests before the one you care about

Section titled “Six requests before the one you care about”

Modern SaaS backends are multi-actor. To exercise admin approves a customer refund, you first authenticate as three different actors and create half a dozen prerequisite records — then copy IDs and bearer tokens between tabs until the request you actually wanted to test finally returns a 200.

Reqloom treats the API as what it already is: a directed graph of resources, actors, and dependencies. You describe that graph once, in a file you can review in a pull request. After that, one command runs any node in it.

Terminal
reqloom run refund.approve --project samples/marketplace
Output
Loaded project: MarketplaceAPI (3 actors, 5 resources)
Running: refund.approve (chain of 7 steps, env=local)
  [1] Running: product.create (attempt 1)
  [2] Running: product.publish (attempt 1)
  [3] Running: cart.add_item (attempt 1)
  [4] Running: order.create (attempt 1)
  [5] Running: order.pay (attempt 1)
  [6] Running: refund.request (attempt 1)
  [7] Running: refund.approve (attempt 1)


Result: SUCCEEDED

Seven requests across three actors — vendor, customer, admin — each logged in as needed. You asked for one endpoint and declared its prerequisites once.

How it works

Four ideas, and that’s the whole model

Section titled “Four ideas, and that’s the whole model”

  1. Actors own credentials. admin, vendor, customer — each with its own auth flow, defined once. Actors →

  2. Resources group operations. A resource declares what it needs to exist before it can be used. Resources →

  3. Dependencies are declared, not scripted. Reqloom topologically sorts them and executes in order. Resolution →

  4. Variables carry values forward. Extract an ID from step 2, reference it in step 6. Variables →

What you get

Built for the parts that usually hurt

Section titled “Built for the parts that usually hurt”

Chains resolved for you

Pick an endpoint. The engine walks your schema, builds the prerequisite chain, and runs it in topological order — reusing anything already satisfied.

Multi-actor by default

Each actor’s login, token refresh, and OTP flow lives in the schema. Sessions are cached, so you don’t re-authenticate every morning.

One schema, every environment

Local, staging, production. Same file, different --env. Secrets stay in your OS keychain, not in the schema.

Reviewable in a pull request

Plain YAML. Diffs are readable, conflicts are resolvable, and the schema lives next to the code it tests.

Importer for what you already have

Turn an OpenAPI spec, a Postman collection, or a pasted curl log into a runnable schema instead of retyping it.

A desktop app and a CLI

Build and debug chains in the workbench — step timeline, response inspection, dependency graph. Run them in CI with the same engine and the same files.

Local-first, Apache 2.0

The engine, CLI, schema, and desktop app are open source. Your projects and run history stay on your machine.

Positioning

Where it sits next to the tools you know

Section titled “Where it sits next to the tools you know”

Postman, Bruno, and Insomnia are HTTP clients: excellent at composing and sending a single request. Reqloom is a workflow engine that happens to speak HTTP — the value is in what it does between requests.

| | Postman | Bruno | Insomnia | Reqloom | | ------------------------------ | ------- | ----- | -------- | ------- | | Send a single request well | yes | yes | yes | yes | | Auto-resolved request chains | no | no | no | yes | | First-class actor abstraction | no | no | no | yes | | Importer for arbitrary specs | partial | no | partial | yes | | Git-friendly schema files | partial | yes | partial | yes | | Open source | no | yes | partial | yes | | Local-first by default | no | yes | no | yes | | CLI built for CI | partial | yes | partial | yes |

If your workflow is one request at a time, an HTTP client is the right tool and Reqloom is overhead. The trade pays off once a request has prerequisites.

Install

Getting it running

Section titled “Getting it running”

Builds for macOS, Linux, and Windows are on the releases page. The installation guide has direct links, checksums, and the first-launch steps each OS needs.

Pick your platform on the installation page — a macOS .dmg, a Linux .AppImage, or a Windows installer. Then confirm it works:

Terminal window
reqloom --help

Next

Pick a path

Section titled “Pick a path”

See it run

The marketplace sample, end to end, with the resolver output explained line by line. 5-minute tour →

Write your first schema

Auth flows, resources, and dependency chains, built up by example. Authoring guide →

Look under the hood

How the resolver orders steps, caches sessions, and keeps the engine free of any UI dependency. Architecture →