Help › Guide
Connections
Reqlyn 0.5.1 is not released yet. This help describes it ahead of release.
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.
Credentials
Choose the kind, give it a name, and press "Add credential". A request then uses it from its Auth tab, by name. These are the kinds:
| Kind | You give | What a request is sent with |
|---|---|---|
| Bearer token | The token | Authorization: Bearer <token> |
| Basic | A user name and a password | Authorization: Basic … |
| Digest | A user name and a password | The request first with no body; from the server's 401, its Digest challenge answered with a hash of the password, the nonce and the request (MD5 or SHA-256, each also -sess, with qop=auth or none), and the request sent whole. The password is never sent. A server's environment binds it too, as kind digest with username. Not for a WebSocket, a gRPC call or a stream. |
| NTLM | A Windows account, DOMAIN\user or user@domain, and its password |
NTLM's handshake on one connection: the request announced, the server's challenge answered, then the request whole. The password never leaves this computer. A server's environment binds it too, as kind ntlm (the server guide). Not for a WebSocket, a gRPC call or a stream. |
| Kerberos | The account, user@REALM, its password, and its KDC: a host, or a host and port (port 88 unless given) |
A ticket to the service HTTP/ and the address's host, asked of the KDC over TCP for each request and sent as Authorization: Negotiate …. The password never leaves this computer. The address's host has to be one of the server's names in the domain (its SPN): an IP address usually is not. A server's environment binds it too, as kind kerberos (the server guide). Not for a WebSocket or a gRPC call. As the signed-in Windows user, without a password, is to come. |
| API key | The header's name, such as X-Api-Key, and the key |
The key in that header |
| OAuth client | The client id, the client secret, the token endpoint and an optional scope | A token Reqlyn asks the token endpoint for, with the client-credentials grant |
| OAuth sign-in | The client id, the provider's authorization page, its token endpoint and an optional scope | A token from signing in through the browser |
| OAuth 1.0 | The consumer key and its secret, the token and its secret if the API gave you one, the signature method (HMAC-SHA1, HMAC-SHA256, RSA-SHA256 or PLAINTEXT) and an optional realm; for RSA-SHA256, the path to the consumer's private key (a PEM file, read once) in place of its secret | Each request signed as it is sent: its method, its address, its query and a form body's fields, as RFC 5849 says, in Authorization: OAuth …. The secrets are never sent, but for PLAINTEXT (use it over HTTPS only). A server's environment binds it too, as kind oauth1 (the server guide). |
| Login | A user name, a password, the login address, where the token is in the answer, and optionally the body to post, the header the token goes in and what goes before it | A token Reqlyn reads from the login's answer |
| AWS Signature Version 4 | The access key ID, the secret access key, the region (us-east-1) and the service (ec2) |
The request signed with the secret access key: Authorization: AWS4-HMAC-SHA256 …, X-Amz-Date and X-Amz-Content-Sha256. The key itself is never sent. A multipart body, a WebSocket and a gRPC call are not signed and are refused. |
| Hawk | The Hawk id and its key | Each request signed as it is sent (HMAC-SHA256 over a timestamp, a nonce, the method, the path and query, the host and port, and a hash of the body unless it is multipart): Authorization: Hawk id=…, ts=…, nonce=…, hash=…, mac=…. The key is never sent; the server's clock has to be within a minute or so of this computer's. A server's environment binds it too, as kind hawk with id. |
| A plugin | The installed auth plugin's name, what it is given (such as a key id) and its secret | Each request signed as it is sent by the plugin's script, in a sandbox with no network and no file: it is given the request's method, address, headers and body, the detail and the secret, and says which headers and query parameters to add, which are sent marked as secret. The secret goes no further than the plugin. See Plugins. On this computer only for now. |
| Signed JWT assertion | The issuer (a GitHub App's id, a service account's email), the path to its RSA private key (a PEM file, read once), and what is sent: the token a token address gives for it (a Google service account: the token address, and the audience and scope it asks), the token in the answer to posting it (a GitHub App: the installation's token address, the token at token), or the assertion itself |
Authorization: Bearer …, with a token bought once and reused until it runs out. The key is checked when it is added and never sent. |
Only the secret part goes to the secret store; the rest (names, addresses, the header) is kept in the database and listed. A credential is never part of a request's definition: a request names it, and the secret is read only when the request is sent. History names the header the credential went in, never its value.
OAuth client
A request that uses an OAuth client makes Reqlyn ask the token endpoint for a token, the client presented in the Authorization header. The token is held in memory and reused until 30 seconds before it expires; it is never stored or shown. A refusal from the token endpoint fails the request with the endpoint's error and error_description, and nothing is sent. When an API answers 401 to a token, the token is dropped, so the next request asks for a new one; the refused request is not sent again.
"Change endpoint" on the client's row edits its token endpoint and scope in place, and how it sends its secret, with Save and Cancel. The secret is never shown or changed there; delete the credential and add it again for a new secret.
OAuth sign-in
"Sign in" on the credential's row opens the provider's page in your browser, with PKCE and a random state, and listens on 127.0.0.1 for the browser to come back. A callback with any other state is refused. The access token is held in memory and the refresh token kept in the secret store, so an expired token is renewed without signing in again. A request sent before signing in says to sign in.
Login
A credential goes only where you have let it. The first time a request would send it to an origin (a scheme, host and port) it has not gone to before, nothing is sent and the response area asks whether it may go there: "Allow and send" lets it go there from now on, "Not now" sends nothing. This holds whoever wrote the request: you, an installed package, a shared or synced request, a Git pull or a coding agent. The origins each credential may go to are listed under it in Connections, each with Remove; reqlyn credential origins <name> lists them and reqlyn credential allow <name> <origin> adds one. A credential that was here before November 18, 2026 starts with the origins of the requests saved before then that name it, their variables filled when it is first sent.
A Login credential is a recipe, not a script. Reqlyn posts the body to the login address once, with {{username}} and {{password}} filled in as JSON strings (they cannot change the body's shape), reads the token at the path you gave (access_token unless you gave another, such as data.token, imdata.0.token for a list's first item, or $ for an answer that is the token itself), and sends requests with it as a bearer token, or in the header you named after what you put before it (X-Auth-Token; Cookie after APIC-cookie=). "Password as Basic" sends the user name and password as HTTP Basic on the login too, as vCenter, Catalyst Center and NSP ask; then the body may be left empty and none is posted. The token is reused until an API answers 401. After three failed logins in a row, no more are tried, so that Reqlyn does not lock the account, until you press "Allow another login" on its row.
Certificate authorities
For servers whose certificates your organization signs itself: give the path of the authority's PEM certificate, and optionally a name, and press "Trust this authority". It is trusted beside the ones this computer already trusts, for every request. A certificate must still name the host it is used for; verification cannot be turned off. An untrusted certificate, and one that names another host, each have their own message.
Try it: send https://localhost:8788/devices to the fixtures, which is refused; trust the reqlyn-fixture-authority.pem they wrote to the temporary folder, and send again.
Client certificates
For servers that ask the client to prove who it is: a name, the certificate's PEM file and its private key's PEM file, then "Add client certificate". The certificate is kept by Reqlyn and the key in the secret store; the files are read once and can be removed afterwards. Choose it on a request's Auth tab beside the credential. A server that turns the client away because of its certificate is named as the likely reason.
The fixtures' https://localhost:8789 admits only a client presenting reqlyn-fixture-client.pem with reqlyn-fixture-client-key.pem.
Proxy
Requests are sent directly unless a proxy is set here: give http://host:port and press "Use this proxy". Every request then goes through it, HTTPS through a tunnel. A request the proxy cannot carry fails, naming the proxy, and is never sent directly instead. A WebSocket and an Arazzo step on an AMQP or MQTT broker go through the proxy or the bastion by their tunnel. A step on a Kafka broker goes through the proxy or the bastion by a bridge Reqlyn opens on this computer for the run; through the bastion it opens only the first broker's port, which a cluster's brokers share. "Send directly" removes it. The operating system's and the environment's proxy settings are never used. The fixtures' proxy on http://127.0.0.1:8790 prints each request it carries.
A proxy that needs a password, an HTTPS or SOCKS proxy, and a list of hosts that skip the proxy are not supported.
SSH bastions
A route through one or more SSH bastions reaches an API that only a bastion can see. Add the hops in order, each with its host, port (22 when empty), user, and either the path of a private key or a password:
- "Check bastion" (then "Check next hop") fetches the hop's host key through the hops already confirmed and shows its fingerprint. Nothing logs in to a hop whose key is not confirmed.
- Compare the fingerprint with one you trust, and press "It matches: trust this key".
- "Use this route" proves every login in order and puts the route in force. A hop that refuses is named, and nothing changes.
Requests then go through every hop, and the last one resolves the destination's name, so an internal name works. The original host name is kept for the Host header and for TLS. A route that cannot carry a request fails it with the reason; nothing is sent directly. A changed host key is a failure, never a prompt to accept it. Host keys are kept with the route, never in ~/.ssh. A password goes to the secret store; an encrypted key asks for its passphrase.
SSH runs inside Reqlyn: no ssh program is needed, and nothing else on the computer can use the route. A proxy and a bastion cannot be set together. "Stop using the bastion" returns to direct sending and forgets the host keys. A server never opens an SSH route: a network a server cannot reach is reached by a private agent.
Cookies
Cookies an API sets are sent back with later requests to it, as a browser does: a login that answers with a session cookie lets the next request in. A cookie goes only to the site that set it (or the domain it named, when that is the site's own or one it is under), on its path, over TLS when it asked for that, until it expires; one with no expiry lasts until Reqlyn closes. A request that writes its own Cookie header sends that one. A request with a credential neither sends nor keeps cookies unless its Auth tab's "Also send and keep cookies with this credential" is on.
Each cookie's value is kept in the secret store, never in the database, history or an export. The Cookies section, at the foot of Connections, lists each by its name, site and path and when it expires, never its value; the cross beside one forgets it, "Forget all" every one.
Connections on a server
On a server, credentials are bound per environment by an administrator, with the origins each may be sent to; see Using a server. The desktop's credentials stay on this computer.
Help for Reqlyn 0.5.1. All help topics