Reqlyn help

Help for Reqlyn 0.5.1.

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

Guide

  • The Reqlyn guide

    Reqlyn is an API workbench and a self-hosted "API of APIs". You send requests and learn an API on your own computer. You compose requests to several APIs into one typed operation, and test it there. Then you publish it to a Reqlyn server, where others run it with the server's credentials, call it as a route or an MCP tool, and are told when an upstream API changes under it.

  • Getting started
  • Requests

    The Requests destination is the first icon on the rail. Its sidebar lists your saved requests (COLLECTIONS) and what you have sent (HISTORY). The work panel is the request editor.

  • Connections

    Connections, the key on the rail, holds what requests are sent with and how they get there: credentials, certificate authorities, client certificates, a proxy, and SSH bastions. Every secret goes to the operating system's secret store (Windows Credential Manager, or the Secret Service on Linux). None is written to Reqlyn's database, history or exports, and a secret cannot be shown again once it is added.

  • Discovery

    Discovery, the compass on the rail, is where an unfamiliar API is learned from what you already have: traffic recorded in a browser, a Postman collection, an OpenAPI description, or recordings of a task done by hand. Nothing in an imported file is sent, fetched or run, and likely secrets are masked as the file is read. A Postman, Insomnia or Bruno collection's scripts are translated, not run here: a collection is taken as an operation, its scripts with it, in Operations ( Operations ).

  • Operations

    An operation gives saved requests typed inputs and a declared output. It sends one or more requests in order, carries values from one response into a later request, and returns only the fields its output contract names. An operation is what you publish to a server, what a route or an MCP tool runs, and what reqlyn run runs.

  • Scripts

    A step of an operation may run JavaScript before its request is sent and after its response comes back. A script changes the request, checks the response, and passes values to later steps. It runs in a sandbox wherever the run does: on this computer, on a server and on a private agent.

  • Arazzo workflows

    Arazzo is the OpenAPI Initiative's format for workflows over APIs: steps that call operations of OpenAPI (and AsyncAPI) descriptions, with inputs, outputs, criteria and actions. In Reqlyn an operation's source of truth is an Arazzo 1.1 document. Reqlyn compiles it to the operation it runs, so the desktop, the command line, the server, routes and MCP tools all run what the document says.

  • Testing and recovery

    An operation is tested on this computer before it is published, and its tests travel with it. This page covers the operations editor's Test run part, the command line's reqlyn run and reqlyn test , and what Reqlyn offers when a run stops part way.

  • Reconciliation checks

    Two systems often hold the same records: an inventory and an IPAM both know each device's address. A reconciliation check reads both through operations you already have, matches their records by an exact key, and says where they disagree. It writes to neither. A correction is a separate step that you, or on a server a second person, approve.

  • Connector packages

    A connector package is a signed file of ready operations for one system: each operation with the requests it sends (as definitions, naming credentials but holding no secret), its output contract, its Arazzo source, its regression cases (masked), and the package's documentation. Packages let a team share what it learned about an API, and let Reqlyn's maintainers ship curated operations.

  • Using a server

    A Reqlyn server keeps what you publish and runs it for others: through its run API, from the desktop's Catalog, as routes under /routes , as MCP tools, on a schedule, or through a private agent in another network. It keeps a record of every run, and watches each version's upstream APIs for change.

  • Encrypted sync

    Your definitions (requests, folders, operations with their sources and cases, credentials' settings, environments, checks) can be kept the same on several computers. They are sealed with a workspace key that only your devices hold, and go through a Reqlyn server or a folder you synchronize yourself (OneDrive, Dropbox, a share). The server or folder holds ciphertext it cannot read. Secret values are never synchronized: each computer keeps its own in its secret store.

  • Command line

    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.

  • Coding agents

    A coding agent (Claude Code, Codex, Cursor, OpenCode) can author a Reqlyn workspace: add requests, build operations from them, test an operation and keep the test as a regression case, then replay the cases. It does so through reqlyn mcp , Reqlyn's authoring MCP server on standard input and output, and the command line in JSON mode ( The command line ).

  • VS Code

    The Reqlyn extension for VS Code sends a folder workspace's requests, runs its operations and replays their regression cases without leaving the editor. It works through the reqlyn command line, so the same secrets, variables and credentials are used as on the desktop, and nothing secret passes through VS Code.

  • Reqlyn in CI

    A pipeline runs the reqlyn command line in the Reqlyn CI image: an operation's regression cases ( reqlyn test ), a data-driven run ( reqlyn run --data ), a mock for the job to call ( reqlyn mock ), and runs on a server ( reqlyn remote ). The image holds the program and nothing else: no secret, no token and no server's address. The repository has a GitHub Action ( ci/github ) and a GitLab template ( ci/gitlab/reqlyn.gitlab-ci.yml ) that run it by a name you set.

  • Error codes

    Every failure has a stable code beside its sentence. The sentence says what happened and what to check; the code is what scripts, JUnit reports, run records and the server's answers carry. Codes are the same on this computer, on a server and on a private agent.

  • Security

    What Reqlyn keeps, where, what leaves your computer, how it is encrypted, and what it never does; and how to report a vulnerability. The design and its boundaries are in ARCHITECTURE.md ; encrypted sync is in SYNC_SECURITY.md ; each surface's threats are in THREAT_MODEL.md .

Tutorials

  • Tutorials

    Five tasks, each from start to finish, against the fixture APIs that come with Reqlyn ( cargo run -p reqlyn-fixtures ). Each was followed as written before it was written down. They build on one another, but each says what it needs.

  • Tutorial 1: a first operation in the desktop

    You will send a request, save two requests, and compose them into an operation that takes a device id and returns its host name and whether it is compliant: one call to an inventory API, one to a compliance API, the second filled from the first. Then you will test it, keep a regression case, see what happens when an API has no answer, and run the same operation from the command line.

  • Tutorial 2: Arazzo workflows

    In Reqlyn an operation's source is an Arazzo document: a workflow of steps over OpenAPI (and AsyncAPI) descriptions. This tutorial works with documents directly, from the command line. You will check, compile and run a workflow; add success criteria and a retry action; let a step be optional; run a WebSocket message workflow; then store the document as an operation, keep a case, and export it.

  • Tutorial 4: CI and the command line

    Operations kept in a repository can be checked on every change, with no desktop and without calling any API: the documents checked and compiled, and their regression cases replayed. Against a server, a pipeline can run a published version once per build, and ask whether a newer upstream description would break anything published.

  • Tutorial 5: Scripts

    A step can run JavaScript before its request and after its response: to check what came back, to pass a value to the next step, and to change the request it sends. This tutorial runs a scripted Arazzo workflow from the command line, watches an assertion fail and the sandbox stop what it must, then takes a Postman collection with tests into the desktop as an operation.

Reference

  • Command reference

    Every command of reqlyn , the command line, as reqlyn help gives it, with its examples. This page is written by the program from its own usage ( reqlyn help --reference ), and a test fails when the two differ. How the commands are used is in The command line .

  • HTTP API reference

    The routes of a Reqlyn server's own API that its web client uses, as the server describes them ( /v1/api.json , reqlyn-server api describe ). This page is written by the program from that description ( reqlyn-server reference api ), and a test fails when the two differ. A caller sends a service token or a session as a bearer token; how the API is used is in Using a server . The OpenAPI description of what a workspace has published, and the clients made from it, are another description, /v1/openapi.json .

Installing

  • Installing the desktop application

    This covers the desktop application and the command line. The server is installed step by step as INSTALL_SERVER.md says; every setting is in DEPLOYMENT.md .

More

  • Account help: signing in, the license and its trial, exports and deleting your account.
  • Support, when the help does not answer your question.