Help › Guide

Command line

Reqlyn 0.5.1 is not released yet. This help describes it ahead of release.

reqlyn runs what the desktop keeps, on this computer, through the same services; and reqlyn remote … drives a server. reqlyn --help lists every command; reqlyn help <command> prints one command's help with examples, such as reqlyn help run or reqlyn help remote run. Every command's help, with its examples, is on one page in the command reference, which reqlyn help --reference prints.

On this computer

Command Does
reqlyn list The stored operations: id, then name
reqlyn run <operation> --input <json> Runs a stored operation and prints its output as JSON. --input-file, --junit <path>, --keep-case <name>, --preview [--read-first], --var <name>=<value>
reqlyn run <operation> --data <file> [--parallel <n>] Runs the operation once for each row of a CSV file (its first line names the columns) or a JSON array of objects, each column one of its inputs, a cell read as the input's kind; --parallel runs that many rows at a time (1 to 64). Prints a line for each row (its number, its time, ok and its output, or failed and why) and a summary; ends with 1 when a row failed. With --junit <path>, a report with a test case for each row. A file is read whole first: a bad row or a column that is not an input runs nothing (exit 2).
reqlyn requests The saved requests: id, method and name; with --json, each one's address too
reqlyn send <request> [--var name=value] Sends a saved request, by its name or id, with the environment's variables and its credential, and prints the status and the body; with --json, its headers and time too
reqlyn test <operation> Replays its regression cases, sending nothing. --pack <file>, --junit, --rename, --ignore, --remove; --generate <n> [--writes] [--plausible] makes cases from generated inputs, each run live and kept
reqlyn migrate <operation> <file> --source <name> Suggests what to read in place of fields a newer description drops; --apply all|<n,n>
reqlyn arazzo check | compile | save | run | export Arazzo documents: see Arazzo workflows
reqlyn mock <file>... [--stateful] Serves on 127.0.0.1 what HAR recordings answered and what OpenAPI descriptions say each call answers (its first success, the media's example or realistic data generated from its schema), with faults; --stateful keeps what a POST makes, read, changed and deleted at its id after
reqlyn draft <openapi file> --prompt <text> Claude drafts an operation over that API from what you ask, with assistance on; prints the question first, --yes sends it and saves the draft, nothing run
reqlyn load <operation> --callers <n> --seconds <n> Runs a stored operation again and again on this computer and prints its runs, latency percentiles and errors by step; its requests are not kept in the history. --ramp, --per-minute, --input, --var; --writes for one that may write
reqlyn load … --p95-under <ms> --errors-under <percent> [--junit <path>] A load run judged by thresholds: ends with 1 only when the runs' p95 time or their share that failed is not under its threshold, each threshold said as within or over; --junit writes a report with a case for each. reqlyn remote load takes the same three (not with --no-wait).
reqlyn docs <folder> Writes this documentation as a website to a folder, with a search and the whole manual as one page to print; it needs no network. --public leaves out installing and running a server
reqlyn fuzz <openapi file> [--operation <id>] [--runs <n>] [--seed <n>] Sends inputs generated within each operation's schemas (100 each unless --runs), as negatives does (--writes, --with-credentials); the first the API fails on (a 5xx or no answer) is made as small as it can be while it still fails. Only through a selected environment that allows fuzzing. Ends with 1 on a failure, 2 when nothing was sent; prints its seed.
reqlyn environment <name> [--create] [--select] [--allows-fuzzing yes|no] Creates an environment, selects it, or marks it as allowing fuzzing (none does at first; the one that always exists never does).
reqlyn negatives <openapi file> Sends each operation requests that break one rule of its description, and others exactly at each bound, through the selected environment, and says which the API accepted or refused against it; exits 1 on any. Writes are sent only with --writes, a credential or secret only with --with-credentials; --keep <file> keeps the cases and answers; --operation <operation> in place of the file keeps them beside its regression cases, for reqlyn test to list
reqlyn demonstrate <recording> <recording>... Compares recordings of one task and drafts an operation; --save, --check, --probe, --yes, --describe
reqlyn check save | list | run Reconciliation checks: see Reconciliation checks
reqlyn snippet <request> --language … A saved request as curl, Python, Rust or TypeScript
reqlyn connector key | pack | check | install | search | index | trust | distrust | trusted Connector packages: see Connector packages
reqlyn workspace-key … The workspace key and folder sync: see Encrypted sync

An operation is named by its name or its id. The data folder is the desktop's (%APPDATA%\Reqlyn on Windows), or REQLYN_DATA_DIR.

Variables on the command line

A run sends its requests with the selected environment's variables. --var <name>=<value>, as often as needed, on reqlyn run and reqlyn arazzo run, sets a variable for that run in place of the environment's. A variable that no environment sets, and that a description's server names, takes the description's default. So a document whose descriptions say where their APIs are runs in an empty data folder, as a CI job's is:

reqlyn arazzo run device-overview.arazzo.yaml --input '{"deviceId": 4831}'
reqlyn arazzo run device-overview.arazzo.yaml --input '{"deviceId": 4831}' --var inventory=https://inventory.lab.example

A secret is never given this way: a name that looks secret (token, password, api_key …), or that is a secret variable of the environment, is refused, and nothing runs. Keep secrets as secret variables, or as credentials under Connections.

On a server

Command Does
reqlyn remote list [<words>] What is published: id, latest version, its state, name, and the most requests a run can send
reqlyn remote environments Where versions can run
reqlyn remote activate <id> <version> <environment> Lets a version run in an environment, once it binds what the version needs
reqlyn remote version <id> <version> active|retired|disabled A version's state
reqlyn remote run <id> <version> --environment <name> --input <json> Runs a version and waits for it; --key, --max-age, --no-wait, --input-file
reqlyn remote run <id> <version> --environment <name> --data <file> [--parallel <n>] [--junit <path>] Asks the server for a run of the version for each row of a CSV or JSON file, as reqlyn run --data does on this computer: that many at a time, each waited for, a line for each row, a summary and a JUnit case per row; ends with 1 when a row did not succeed.
reqlyn remote status | events | cancel <run> A run as the server tells it; what it did; cancelling it
reqlyn remote resume <run> [--from <step>] [--yes] Resumes a failed run as a new run
reqlyn remote undo <run> <step> --yes Sends a step's undoing request, once
reqlyn remote preview <id> <version> --input <json> [--read-first <environment>] What a run would send
reqlyn remote upload <file> Uploads a file for a file input
reqlyn remote apply <manifest> [--yes] The deployment manifest: its plan, then applied
reqlyn remote approvals | approve | refuse Activations waiting for a second person
reqlyn remote drift | impact | changes | webhook Upstream change: see Using a server
reqlyn remote tool <id> <version> allow|disallow Offers a version that writes as an MCP tool
reqlyn remote audit The audit trail
reqlyn remote agent add | revoke, reqlyn remote agents Private agents
reqlyn remote check …, reqlyn remote checks, reqlyn remote plan … Checks and their plans on the server
reqlyn remote connector …, reqlyn remote connectors The workspace's package registry
reqlyn remote sdk --language … --out <folder> A typed client of every published version
reqlyn remote portal export --out <folder> The public portal as plain HTML and CSS
reqlyn remote demonstrate, reqlyn remote assistance Tasks from recordings on the server, and Claude assistance
reqlyn remote load <operation id> <version> --environment <name> --callers <n> --seconds <n> Runs a version again and again on the server, under the shared rate limits, where an administrator lets the environment take load; prints its runs, latency percentiles and errors by step. --ramp, --per-minute, --input, --writes, --no-wait; remote load-status, remote load-stop, remote load-policy <environment> [on|off]
reqlyn remote explain <run> Asks the workspace's model why a failed run failed; a fix it proposes is saved as a new draft to review
reqlyn remote draft <openapi file> --prompt <text> Has the server ask Claude to draft an operation, saved as a new draft to review; prints the question first, --yes sends it
reqlyn remote workspace-key … Encrypted sync through the server
reqlyn remote release, reqlyn remote license Whether a newer Reqlyn is out; the server's license

The remote commands use no data folder. The server is REQLYN_SERVER (such as https://reqlyn.example) and the service token REQLYN_TOKEN. The token is never given as an argument, and is sent only over HTTPS or to a server on this computer.

For a program or a coding agent

Put --json before any command and it prints one JSON object for it instead: ok and exit, how it ended; result, what it printed when that is JSON, else output, its text; and said, what it said on standard error. list gives its operations (id, name), run the output, and test each case (name, holds, error, differences) with how many hold. It exits as the command does.

reqlyn --json test "Device overview"

A coding agent on this computer authors through reqlyn mcp, an MCP server on standard input and output. It reads the workspace's saved requests (secret headers masked), operations, variables (a secret's value left out) and cases, and saves each change at once: a request, a variable that is not a secret, an operation with its steps, inputs and outputs, a case kept from a test. A request or variable that would hold a secret is refused. It tests an operation that only reads, and replays its cases (test_cases) sending nothing; a test that writes is not run from it. With --folder <path> the folder is the workspace: its files are the definitions, so what the agent changed is a diff to review in Git, and the index and runs are kept in .reqlyn inside it, which Git ignores. Without it, the desktop's workspace is used.

{ "mcpServers": { "reqlyn": { "command": "reqlyn", "args": ["mcp", "--folder", "."] } } }

Exit status

Status Means
0 The run returned its whole output (for status and cancel: the server answered)
1 It failed, or was cancelled or interrupted; a check, case or comparison did not hold
2 It was not run: no such operation, an input that is not JSON, or a server that refused or could not be reached
3 It returned part of its output, having gone on without a step that failed

A failure prints its sentence and its code to standard error, and the output (when there is one) as JSON to standard output.

Environment variables

Variable For
REQLYN_DATA_DIR The data folder of the desktop and the local commands
REQLYN_FOLDER A folder workspace: a folder whose files are the requests, with its own data folder under the one above (see Requests)
REQLYN_SECRET_SERVICE The name secrets are filed under in the OS secret store
REQLYN_EXPORT_DIR Where exports go in place of Downloads
REQLYN_BROWSER The browser a sign-in opens
REQLYN_SERVER, REQLYN_TOKEN The server and service token of the remote commands
REQLYN_SECRET_<NAME> A secret variable's value where no secret store can be reached, as in CI (see Reqlyn in CI)

The server's and the agent's settings are in DEPLOYMENT.md.

In CI

A pipeline usually needs no desktop: reqlyn arazzo check and reqlyn arazzo compile on the documents in the repository, reqlyn test --pack on their cases, reqlyn arazzo run --var … against a test API, and reqlyn remote run against a server, each with --junit where it takes one. The tutorial CI and the command line puts them together. Reqlyn in CI has the CI image they run in, the GitHub Action and the GitLab template.

Help for Reqlyn 0.5.1. All help topics