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