On this page

Connect. Test. Deliver.

User Guide · version 0.12.1

DIALeQ is a desktop API client for building, sending, testing and sharing API requests. It works on your own computer: your collections, environments and settings are stored locally, nothing syncs in the background, and it has no telemetry. It connects only to:

  • The APIs you send requests to
  • DIALeQ’s own service, only when you ask: to verify who you are, to buy Pro online and keep it current, and to send a request or crash reports
  • The same service for a shared workspace, when you push it or get its latest version

Contents

What you can do with DIALeQ:

  • Send HTTP, GraphQL, SOAP, Server-Sent Events (SSE) and gRPC requests, with full control over query params, headers, body and authentication, including OAuth 2.0, client certificates, proxies and cookies.
  • Test AI APIs: watch an answer stream in, and see the tokens it used and what it cost.
  • Open live WebSocket connections and talk to MCP servers (Model Context Protocol): browse and call their tools, read resources and get prompts.
  • Connect to message brokers and event servers (MQTT, Kafka, Socket.IO, AMQP such as RabbitMQ, and NATS): subscribe, publish, and watch every message in one timeline.
  • Organize everything into workspaces, collections and folders, and save response examples of what each request returns.
  • Use environments and {{variables}} to switch between setups such as local, staging and production, and (with Pro) keep API keys and passwords in the encrypted vault.
  • Write pre-request and test scripts, and run a whole collection as a test suite with a pass/fail report.
  • With Pro, run a collection with data (once per row of a CSV or JSON file, compared against a baseline) and load test it with many virtual users.
  • With Pro, run collections, checks and mocks from the terminal or in CI with dialeq.
  • With Pro, check MCP servers for poisoned or changed tools, and run security checks on your API: what a response gives away, access as other users, input handling, and its protocols.
  • With Pro, start a mock server that answers like your API from its examples and specs (HTTP, GraphQL, SOAP, SSE, gRPC, WebSocket and MCP), or records and replays the real one.
  • Import from Postman, OpenAPI, WSDL and cURL, and generate code snippets from any request.
  • Export and import dialeq files to share your work with teammates.
  • With the Pro Team plan, share workspaces with your team: get the latest version, push your changes, and settle conflicts item by item.
  • Find anything you’ve sent in History, and reach every action from the command palette.

Plans compared

Three terms describe what you have:

  • Edition: what this build of dialeq includes, set when it’s built. This is the Pro Max edition.
  • Licence type: Standard (free, no licence needed) or Pro.
  • Licence plan: Standard Free, Pro Personal (one person), Pro Team (seats for a team) or Pro Enterprise (for an organisation).

Settings → Licence… and Diagnostics show your licence type and plan.

Feature Standard Free Pro Personal Pro Team Pro Enterprise
HTTP, GraphQL, SOAP, SSE, gRPC ✓ ✓ ✓ ✓
WebSocket & MCP ✓ ✓ ✓ ✓
Message brokers ✓ ✓ ✓ ✓
Collections & environments ✓ ✓ ✓ ✓
Scripts & tests ✓ ✓ ✓ ✓
Collection runner ✓ ✓ ✓ ✓
Import & export ✓ ✓ ✓ ✓
History ✓ ✓ ✓ ✓
Vault — ✓ ✓ ✓
Data-driven runs — ✓ ✓ ✓
Reports & baselines — ✓ ✓ ✓
Load tests — ✓ ✓ ✓
MCP checks — ✓ ✓ ✓
Security checks — ✓ ✓ ✓
Mock servers — ✓ ✓ ✓
Command line & CI — ✓ ✓ ✓
Team seats — — ✓ ✓
Shared workspaces — — ✓ ✓
White-label — — — ✓
SSO — — — ✓
Enterprise capabilities — — — ✓

Installing dialeq

dialeq runs on Windows. To install it:

  1. Run the installer you were given, dialeq Setup 0.12.1.exe.
  2. If Windows shows “Windows protected your PC”, click More info, then Run anyway.
  3. Follow the installer. You can choose the install folder, and whether to include the sample workspace (it’s left out unless you tick Include the sample workspace).
  4. Start dialeq from the Start menu or the desktop shortcut.

Updates

dialeq doesn’t check for new versions. To update it, run a newer installer: it installs over the version you have and keeps your requests and settings.

The first time a new version opens, a short screen says which version you’re on now. If you have the sample workspace, it says it was replaced with the new version’s; if you don’t, it offers to add it (tick Add the sample workspace, then Continue).

Uninstalling

Open Windows Settings → Apps, find dialeq, and choose Uninstall.

To keep your work, export your workspace first (see Sharing your work).


First launch

The first time dialeq opens, it asks who you are. Then a short welcome screen introduces its main features. Dismiss it to start working. Neither appears again.

Where no installer asked about the sample workspace (on a Mac, or installed as an MSIX package), the welcome screen offers it: tick Add the sample workspace before Get started. It’s left out unless you do.

dialeq remembers the tabs you had open and reopens them the next time you start the app.

The main window

  • Header (in the layouts that have one; the IDE Style layout has none): the workspace dropdown (briefcase icon; its last item, Manage workspaces…, opens the Workspaces view), the environment switcher ({ } icon: the set of variables currently in use; its last item, Manage environments…, edits them), and Settings (the gear button at the right) for the settings menu.

  • Activity bar (the icon strip on the far left): at the top, it picks what the sidebar shows, one section at a time:

    • API: saved HTTP, GraphQL, SSE, gRPC and SOAP requests.
    • WebSocket: saved WebSocket connections.
    • MCP: saved MCP servers.
    • Messaging: saved broker connections (MQTT, Kafka, Socket.IO, AMQP, NATS).

    Under a line, the briefcase opens the Workspaces view and { } the environments. At the bottom: History (the requests you’ve sent, in the sidebar; see History), the theme, app theme and layout icons (see Theme, app theme and layout), ? this guide and, last, Settings (the gear) for the settings menu. Click the section already shown (or History) to hide the sidebar, and any section to show it again. Layouts without the activity bar have History, the theme, app theme and layout icons, ? and Settings at the right of the header.

  • Sidebar: the chosen section’s collections. Drag its right edge to make it wider or narrower. dialeq remembers the section, the width and whether the sidebar is hidden.

  • Main panel: what you’ve opened, one tab each (see Tabs). That can be a request and its response, a WebSocket connection, an MCP server, a messaging connection, or the details of a collection or folder.

  • Bottom panel: tabs under the sidebar and main panel.

    • Logs is always there: a running log of every request sent, connection events (connecting, disconnecting and why, errors), the messages you send, MCP calls, subscriptions and publishes, GraphQL schema and gRPC reflection fetches, collection runs, data-driven runs and load tests, mock servers, security checks, and script output. Turn on Trace to log everything in full: each request as written, for its protocol (an HTTP request’s params, headers, auth and body; a GraphQL query and its variables; a SOAP action and envelope; a gRPC method, metadata and message; a WebSocket’s subprotocols; an MCP server’s command or URL; a broker’s options), each response (status, headers and body, or a gRPC call’s trailers and reply), every stream message either way, each MCP call’s arguments and result, and each request of a collection run with its response, tests and script output. Passwords and secrets are never logged, and an MCP server’s environment shows its names only. Click Clear to empty the log.
    • A collection run (and, with Pro, a run with data, a load test, a mock server or security checks) opens in a tab of its own, named for what it is and the collection or folder: Run: Orders, Data: Orders, Load: Orders, Mock: Orders or Security: Orders. Runs of different folders, and one folder’s run, data run and load test, each keep their own tab and results (see Running a collection). Settings → Diagnostics opens in a Diagnostics tab. Close any of them with the × on its tab. When there are more tabs than fit, scroll the row sideways.
    • The panel starts collapsed; click the arrow on its header to expand or collapse it. Drag its top edge to change its height.
  • Manage environments and Import open in a panel over the right edge of the window. Press Escape, or click outside it, to close it.

Tabs

Everything you open gets a tab above the main panel, showing its protocol, its name and, when there are unsaved changes, a dot.

  • Preview tabs: a single click in the sidebar opens the item in a preview tab (its name in italics), which the next item you click replaces, so browsing doesn’t pile up tabs. A tab is kept once you edit it, send it or connect it, or when you double-click the tab. New requests and connections open in kept tabs, and so does each collection or folder you open, so opening another doesn’t replace it.
  • Switching: click a tab, press Ctrl+Tab and Ctrl+Shift+Tab, or use the arrow keys once a tab has focus. Each tab keeps its own edits and response, and a WebSocket or MCP connection keeps running while its tab is in the background.
  • Closing: click × on a tab, middle-click it, press Delete while it has focus, or press Ctrl+W. Closing a tab closes its connection. If the tab has unsaved changes, dialeq asks whether to save them first.
  • Reordering: drag a tab to a new place.

Deleting an item closes its tab, and renaming it renames the tab.

Theme, app theme and layout

Each is an icon that opens its choices, the current one ticked; only those with more than one choice show. They sit at the foot of the activity bar, above ?, or at the right of the header in a layout without the activity bar.

  • Theme (its icon shows the one you’re using; its name, under System, says which theme that is right now): System (the default) follows your computer’s light or dark setting and switches when it does. Dark and Light keep dialeq in one theme. High contrast is a black theme with white text and bright colours, stronger borders and a thicker focus outline, for the most legible text (WCAG AAA contrast). Your choice is remembered. Windows’ own high-contrast themes (Settings → Accessibility → Contrast themes) work too: dialeq then uses your system’s colours.

    dialeq’s icon in the taskbar (Windows) or the Dock (Mac) follows your computer’s theme rather than dialeq’s: a light icon on a light taskbar, and a high-contrast one while a contrast theme is on. On Windows, dialeq’s Start menu, desktop and pinned taskbar shortcuts change with it (they catch up when dialeq next runs, if you change the theme while it’s closed). The installer and dialeq.exe itself keep the standard icon.

  • App theme: how dialeq looks: its colours, corners, shapes and type. Choose from Classic (the standard one), Atelier and Pop. It changes at once, works with every Theme above (each app theme has its own dark, light and high-contrast colours), and is remembered. The icons in the taskbar, the Dock and the installer stay dialeq’s standard ones.

  • Layout: where things are on the screen: the categories, the sidebar, the tabs and the panels. Choose from IDE Style (the standard one), Focus and Top navigation. It changes at once and keeps your open tabs, unsaved changes and connections; each layout remembers its own panel sizes.


Workspaces

A workspace holds everything you work on: its collections, folders, requests and connections, its own environments (global environments are shared by every workspace), its History, cookies and OAuth 2.0 tokens, its response examples, the tabs you had open and this session’s logs. dialeq starts with one, My Workspace, and you can add more, for example one per project or client. One is open at a time, and dialeq reopens the last one you used.

In the IDE Style layout, the briefcase in the activity bar opens the Workspaces view, where Open on a workspace’s card switches to it. The other layouts also have a workspace dropdown in the header (the briefcase icon), next to the environments:

  • Switch by choosing another workspace. Its tabs come back as you left them. If a tab has unsaved changes, dialeq asks whether to save them first.
  • Search: type in the box at the top of the dropdown to narrow the list down by name; the arrow keys and Enter choose too.
  • Manage workspaces…, its last item, opens the Workspaces view, where you create, rename, clear, delete, export and import workspaces.

Managing workspaces

The Workspaces view (Manage workspaces… in the workspace dropdown, or Workspace: Manage workspaces in the command palette) takes the place of the tabs in the main panel. It shows every workspace as a card with a count of what’s in it: requests, WebSocket, MCP and messaging connections, folders, History entries and cookies, and the names of its own environments, with Manage environments… to edit them (and the global ones), whether the workspace is open or not. The open one is marked Currently open.

At the top:

  • Create new workspace… makes an empty workspace and opens it.
  • Import new workspace… imports a dialeq export into a new workspace (named after the file; you can change the name) and opens it.

On each card:

  • Open opens that workspace. The view stays open.
  • Rename renames it.
  • Export exports everything in it to a file; see Sharing your work.
  • Import imports a dialeq export into it. A workspace that isn’t open stays closed.
  • Clear deletes everything in it (collections, its own environments, History, cookies and OAuth 2.0 tokens) and keeps the workspace, with its name. Global environments stay.
  • Delete deletes the workspace and everything in it. It’s greyed out when there’s only one workspace; that one can be cleared.

Close the view with ×, or open anything from the sidebar.

Settings (the theme, Network…, History limits) are the same for every workspace. When you import a dialeq export from a section header or the Import panel, you choose whether it goes into the open workspace or a new one.

Shared workspaces (Pro)

Members of a Pro Team purchase can share workspaces with each other. Each shared workspace has owners, editors and viewers:

  • Everyone with a role can import it and get its latest version.
  • Editors and owners can push their changes as a new version.
  • Owners also give and take away roles, and can delete it. The Pro Team purchase’s owners are always owners.

Only people holding a seat on the purchase can have a role. Sharing needs you to verify yourself and a Pro licence that includes shared workspaces.

Everyone works on their own copy, on their own computer, and nothing changes until they ask: there’s no syncing in the background. Your History, cookies, OAuth 2.0 tokens, baselines, the vault and global environments are never shared.

Sharing a workspace: in the Workspaces view, click Share… on its card. With more than one Pro Team purchase, choose the one to share it with, by its name (its team’s name, then the name its owners gave it, or its plan and term), then Share: only that purchase’s members can have roles in it. You become its owner, and its first version is pushed. Before anything is shared, dialeq looks for values that seem to be credentials, such as a password, a bearer token or an API key header: if it finds one, it names the item and shares nothing. Mark each environment variable that holds one as Secret in Manage environments: its name is shared, and everyone keeps their own value. Put any other credential into such a variable, as {{name}}, or into the vault (everyone then keeps their own value under the same {{vault.name}}), and share again. When a shared workspace has secret variables with no value on your computer, a note above the tabs names them, with Manage environments… to set yours.

Importing one shared with you: click Shared workspaces… at the top of the Workspaces view. It lists your Pro Team purchases and the workspaces you have a role in, with your role and the latest version. Import makes a copy on this computer and opens it.

A shared workspace’s card shows Shared with your role and the version you have, and the workspace dropdown marks it Shared. On its card:

  • Get latest brings in the newest version. Your own changes are kept and merged with it, item by item. When the same item (a request, a folder, an environment…) was changed both by you and in the new version, a dialog lists each one: keep mine or theirs, then Apply. Nothing changes until you do.
  • Push… asks for a short description and pushes your changes as the next version. If someone pushed since you last got the latest, it offers to get it first, then pushes.
  • Discard my changes puts your copy back to the last version you got or pushed.
  • Members & roles… (owners) lists who has which role: change one, take it away, or give a role to someone with a seat who doesn’t have one yet. They’re told by email. Delete shared workspace… deletes it for everyone; every copy stays on its computer as an ordinary workspace.

When you open a shared workspace, dialeq checks whether there’s a newer version and says so above the tabs, with Get latest. If a tab you’re editing shows an item that a version you got changed, the tab keeps your edits and says who changed it: Reload takes theirs, Keep mine keeps yours (saving then replaces theirs).

If your role is taken away, your seat is freed or the workspace is deleted, dialeq tells you the next time you use it, and your copy stays as an ordinary workspace. If the Pro Team purchase lapses, its shared workspaces can’t be used until it’s renewed, and while your licence doesn’t include shared workspaces, their copies are hidden; they come back with it.

Collections and folders

Every saved request, connection and server lives in a collection. Collections can contain folders, and folders can contain sub-folders. Each section starts with one collection: My Collection (API), My Connections (WebSocket), My MCPs (MCP) and My Brokers (Messaging). You can rename or delete these like any other collection.

Working with the tree

  • Click the arrow next to a collection or folder to expand or collapse it.

  • Hover over a collection or folder to see its quick actions:

    • New request / connection / server here
    • New folder
    • ▶ Run (API only)
    • Duplicate
    • Rename
    • Delete

    Requests and connections have Duplicate, Rename and Delete too. Every icon has a tooltip.

  • Duplicate makes a full copy as a sibling, right after the original, named “name copy”: a collection or folder with everything in it (its folders, requests, connections and response examples, keeping their names), or a request (with its examples) or connection. The copy opens. It copies what’s saved, so save first to include unsaved changes. A request’s and a connection’s toolbar has Duplicate as well.

  • Click a collection or folder’s name to see its details in the main panel:

    • its type and creation date
    • how many folders and items it holds
    • a clickable list of its contents
    • buttons for every action: New, New folder, Run all, Run with data and Load test (API), Mock (API, WebSocket and MCP) and Security checks (these four with Pro), Export, Duplicate, Rename and Delete

    In the details view, you can also click the name at the top to rename it.

  • The new collection icon on a section’s header creates a new top-level collection. The header also has import and export icons.

  • Double-click any name in the tree to rename it.

  • Drag and drop to:

    • reorder collections or folders among their siblings
    • reorder items within a folder
    • move an item into a different folder of the same section

Building and sending requests

Create a request with the new request icon on any API collection or folder, and click its protocol: HTTP, GraphQL, SSE, gRPC or SOAP (Cancel closes the dialog). It’s created at once with a default name, such as New HTTP request; click the name to rename it. The protocol is fixed once the request is created.

The toolbar above a request shows its name, where it lives, and buttons to undo, redo, rename and delete. Click the name to rename it in place. A dot next to the name means you have unsaved changes; click Save to keep them. If you close the tab, or close dialeq, while changes are unsaved, dialeq asks whether to save them first.

The request tabs are Params, Auth, Headers, a body tab (Body, Query or Message, depending on the protocol), Settings, Pre-request Script, Tests, Mock Script (with Pro; see Mock servers) and </> Code. A dot on a tab means it has content. Click a tab again to close it.

TLS certificates

dialeq checks the server’s TLS certificate for every https:// and wss:// connection, and refuses a server whose certificate is self-signed, expired or issued for another host. The error in Logs says why, for example self-signed certificate (DEPTH_ZERO_SELF_SIGNED_CERT).

To test a server like that, turn the check off:

  • For everything: untick Settings → Verify TLS certificates (or run Network: Turn TLS certificate checks on or off from the command palette). It’s on by default. Every request, WebSocket and messaging connection and MCP server that doesn’t set its own follows it, so turning it back on turns the check back on for all of them.
  • For one of them: set Verify TLS certificates to Off for this request (or connection, or server), or On for this … to check it even while the setting is off. It’s on the Settings tab of a request, a WebSocket connection or a messaging connection, and the Headers / TLS tab of an MCP server over HTTP. As in Settings (the default) follows the setting, and shows whether it’s on or off.

A warning shows while the check is off, and a dot marks the tab. The connection is still encrypted, but dialeq no longer checks who it’s talking to, so only do this for servers you control, and only where you need it.

Importing a cURL command with -k or --insecure, or a Postman request with SSL certificate verification off, sets that request to Off for this request, and the </> Code snippets include each language’s equivalent.

Proxy and client certificates

Settings → Network… sets how dialeq reaches servers, for every request and connection:

  • Proxy. By default dialeq uses the proxy in the HTTPS_PROXY or HTTP_PROXY environment variable, if one is set, except for the hosts in NO_PROXY. Choose This proxy to enter one (http://proxy.example.com:3128), with a username and password if it needs them, and the hosts to reach directly under No proxy for (localhost, .example.com: a host covers its subdomains). The system’s proxy settings uses the proxy your operating system is set up with (on Windows, Settings → Network & internet → Proxy), including a setup script (PAC) or automatic detection, which is how most company networks set it: each request asks the system which proxy its address goes through. No proxy turns it off. HTTP, GraphQL, SSE, WebSocket, gRPC and MCP requests go through the proxy, and so do MQTT over WebSocket (ws://, wss://) and Socket.IO; Kafka, AMQP, NATS and MQTT over TCP connect directly.
  • Certificate authorities. Add a CA certificate (PEM) your company signs its servers’ certificates with, and dialeq trusts it as well as the system’s, so you don’t have to turn Verify TLS certificates off.
  • Client certificates. For servers that ask for one (mutual TLS): the host it’s for, and either a PEM certificate and its key or a PFX / PKCS #12 file, with its passphrase if it has one. api.example.com covers its subdomains, *.example.com only the subdomains, and :8443 after a host limits it to that port. Every protocol that uses TLS sends it, messaging brokers included.
  • HTTP/2. Use HTTP/2 when the server offers it (off by default) lets HTTPS requests, collection runs and load tests use HTTP/2 where the server agrees to it, through a proxy and with client certificates too; plain http:// requests stay on HTTP/1.1.

dialeq keeps only the files’ paths, so the certificates stay where they are. Passwords and passphrases are encrypted with your system’s key store and are never exported. The settings apply to requests and connections from the next one you send or open.

Cookies

dialeq keeps cookies the way a browser does. When a response sets a cookie, it’s kept, and sent with later requests to the same site: log in once and the requests after it are logged in too, including in a collection run. A cookie goes only to its own domain (and its subdomains, if it says so) and path, a Secure one only over https:// (or to your own machine), and it’s dropped when it expires or the server clears it. Redirects keep cookies too, so a cookie set by a login’s redirect isn’t lost. A cookie with no expiry is kept until you delete it.

The response’s Cookies tab shows what that response set. To see every kept cookie, open Settings → Cookies… (or Cookies: Manage in the command palette): they’re listed by domain, and you can add, edit or delete one, or delete all of a domain’s. Each workspace has its own cookies.

To send a request without them, untick Use the cookie jar on its Settings tab: it then sends no kept cookies and keeps none it’s given. A Cookie header you add yourself is always sent; for a cookie in both, yours wins.

HTTP

  1. Pick a method (GET, POST, PUT, PATCH, DELETE, HEAD or OPTIONS) and enter the URL.

  2. Add Params and Headers as key/value rows. Untick a row to switch it off without deleting it.

  3. Choose Auth:

    • No Auth
    • Basic Auth (username and password)
    • Bearer Token
    • API Key, sent as a header or a query parameter
    • Digest Auth (username and password): dialeq answers the server’s Digest challenge and sends the request again
    • OAuth 2.0: see OAuth 2.0 below
  4. Choose a Body:

    • JSON or Raw text
    • x-www-form-urlencoded or Form Data (key/value rows). In Form Data, a row’s Type can be File: choose the file, and it’s sent as a file part named after the file, with a Content-Type from its extension.
    • Binary: a file, sent as it is. Click Choose file…; dialeq shows its name and size. Only the file’s path is saved, and the file is read each time you send, so a changed file sends its new contents (and a moved one shows File not found).

    dialeq sets a matching Content-Type header for you. For a binary body it comes from the file’s extension (.png sends image/png), unless you set one in Headers.

  5. Click Send.

The response shows the status, time taken and size, then five tabs: Body, Headers, Tests (with how many passed), Cookies and Timing, and with Pro a sixth, Security (see Security checks). Very large responses (over about 500 KB) show a preview of the body first, with a button to load the full response. dialeq keeps at most the first 10 MB of a body, in sends and collection runs alike: a bigger download is counted to its full size, the viewer says how much of it was kept, and Copy and history have that part.

Body shows JSON and XML Pretty (formatted and coloured) or Raw (as received), and an HTML page as a Preview too. The preview runs no scripts and loads nothing from the network, so it’s safe to look at any page. Search marks every match (Enter and Shift+Enter, or the arrows, step through them), and Copy copies the whole body.

Cookies lists the cookies the response set: name, value, domain, path, when they expire, and their flags (Secure, HttpOnly, SameSite).

Timing shows where the time went: DNS (looking up the host name), Connect, TLS (the secure handshake), Waiting (from sending the request to the first byte of the response) and Download. A request that reused an open connection has no DNS, connect or TLS time. For an HTTPS response it also shows the TLS connection: the version and cipher, whether the certificate was trusted, and the certificate’s subject, issuer and dates. It also says which HTTP version the response came over (HTTP/1.1, or HTTP/2 with that setting on in Settings → Network…).

The request and the response share the main panel. Drag the line between them to give either more room, and click Side by side (or Stacked) to put the response beside the request or under it. dialeq remembers both. WebSocket, MCP and messaging connections split the same way, with the same switch: the connection’s settings on one side, and its messages (or, for MCP, what the server returns) on the other.

Response examples

To keep a response as an example of what a saved request returns (the happy path, a 404, an error), click Save as example next to its status and give it a name. Examples are listed under their request in the sidebar (click the arrow beside the request to show or hide them); click one to open it in a tab of its own, with its status, headers and body. From there you can Rename or Delete it, or go back to its request.

An example also keeps the request it answers, as you had written it when you sent it ({{variables}} as written, without its auth). Open Request on the example’s tab to see it and to choose what a mock server must find in an incoming request to answer with this example: its query parameters (all of them to start with), any of its headers, and its body (as JSON, the example’s fields must be in the request; otherwise the same text). Tick Default example to have a mock answer with it when no other example of the request matches more closely; a request has one default at most.

An SSE request’s stream can be saved as an example too (Save as example under its events): its messages, with how long after each other they came, so a mock server replays them with the same timing. So can a unary gRPC call’s result: its status code and details, its metadata, and the response message as JSON, kept with the message it was called with. A streaming gRPC call can be saved once it has finished (Save as example under its status): its messages both ways with how long after each other they went, its status and the server’s metadata. On the tab of a bidirectional call’s example, Replies adds rules for what the client sends after the replay: when a message (as JSON) has a rule’s text or matches its /pattern/, the mock sends the rule’s reply, a JSON message that can use {{message.field}}; Save rules keeps them.

A WebSocket connection’s mock rules, an MCP server’s saved results (with the contract its checks kept), and the specs a workspace keeps go into exports and shared workspaces too.

Examples are saved with the request, go with it into exports (with secret headers such as Set-Cookie, and secret query parameters, blanked unless you include secrets), and are deleted with it. A Postman collection’s saved responses import as examples, with the request Postman saved for each.

OAuth 2.0

Pick OAuth 2.0 on the Auth tab of an HTTP or GraphQL request, then a Grant type:

  • Authorization code (with PKCE), for signing in as a user: fill in the provider’s Authorization URL, Token URL and Client ID (and Client secret, unless it’s a public client). When there’s no token, your browser opens the provider’s sign-in page; after you sign in, it sends you back to dialeq on this computer (http://127.0.0.1, on a free port, unless you give a Redirect URI, for a provider that only accepts a registered one).
  • Client credentials, for one service calling another: the Token URL, Client ID and Client secret.
  • Password, for older APIs that take a username and password.

Scope and Audience are sent if you fill them in. The token goes in the Authorization header as Bearer … (change Header prefix if the API wants another word), or in the access_token query parameter. Send the client ID and secret chooses how they reach the token URL: as a Basic auth header (the usual way) or in the request body. Any field can use {{variables}}, so the client secret can live in your environment.

dialeq gets a token when you first send the request, keeps it, and uses it until it expires; then it uses the refresh token, if the provider gave one, or gets a new token. Requests with the same provider, client and scope share one token, so you sign in once. Under the settings, Access token shows the token and when it expires, with Get new access token, Copy token and Clear token. Tokens are kept with the workspace, never in the saved request, so they’re not in exports.

GraphQL

Write your query in the Query tab. Add an operation name if the query defines more than one operation, and variables as JSON if you need them. Click Fetch schema to load the server’s schema and browse its types and fields while you write. If the server returns GraphQL errors, they’re listed clearly above the response.

Server-Sent Events (SSE)

Enter the stream URL and click Connect. Events appear live as they arrive. Click Disconnect to close the stream.

Streaming an AI API’s answer

AI APIs (OpenAI, Anthropic, and the many compatible with OpenAI’s, such as local model servers, and Gemini) stream their answers as events in reply to a POST. To test one, create an SSE request, choose POST, and on the Body tab write the request as JSON, with streaming turned on:

{
  "model": "gpt-4o-mini",
  "stream": true,
  "messages": [{ "role": "user", "content": "Say hello" }]
}

Put the API key where the API wants it: Auth → Bearer Token for OpenAI, or an x-api-key header (and anthropic-version) for Anthropic. Click Connect: above the events, Answer shows the text put together as it arrives, and which API’s format it’s in. A request without "stream": true gets the whole answer at once; it shows the same way. If the API refuses the request (a wrong key, an unknown model), the error shows the API’s own explanation.

Tokens and cost

When an AI API’s answer says how many tokens it used (OpenAI, Anthropic and Gemini all do), dialeq shows them under the answer: input, output and total, with the model. For OpenAI’s streams, ask for them with "stream_options": { "include_usage": true } in the body. It works for a plain HTTP request to an AI API too, under the response’s status.

The cost is shown when the model is in the price table, Settings → AI model prices…. It starts with the main OpenAI, Anthropic and Gemini models, at the prices their price pages gave on the date shown there; prices change, so check yours. Edit a price, + Add model for any other (a local model, another provider), or remove one, then Save; Use the starter prices goes back to the table dialeq came with. A price covers its model’s dated versions too (claude-haiku-4-5 covers claude-haiku-4-5-20251001), but not other models whose names start the same way. Discounts for prompt caching and batches aren’t counted.

SOAP

For a SOAP web service, create a SOAP request and enter the service’s address. On the Envelope tab:

  • SOAP version: 1.1 sends the envelope as text/xml with a SOAPAction header; 1.2 as application/soap+xml, with the action in the content type.
  • Action: the operation’s action URI, as the service’s WSDL gives it (soapAction). Some services need it; others ignore it.
  • The envelope itself, which starts from a template: put the operation in its Body. {{variables}} work here too.

dialeq POSTs the envelope. The response body shows as formatted XML, and if the service answers with a fault, its code and reason (and detail) show above the response. A Content-Type or SOAPAction header you add yourself is sent as you wrote it. Code snippets, collection runs and History treat a SOAP request as the HTTP request it’s sent as.

To start from the service’s WSDL instead, import it (Import → WSDL (SOAP), from its URL or a file): you get a request for each operation with the address, version and action filled in, and an envelope with the operation’s elements. Each value is a ? or a sample (0, false, a date, an enumeration’s first value) to replace; optional elements are marked <!--Optional:--> and repeated ones <!--One or more:-->. A service with both SOAP 1.1 and 1.2 ports gets a folder for each.

gRPC

  1. Enter the server address, e.g. localhost:50051.
  2. In the Message tab, say where the service definitions come from:
    • Proto file: paste the service’s .proto definition (one file, without imports).
    • Server reflection: click Load services from the server, and dialeq asks the server itself, so you need no .proto file. The server must have gRPC server reflection turned on (most frameworks have a one-line switch for it). Reload from the server picks up changes.
  3. Pick the service and method. Streaming methods say which kind they are.
  4. Fill in the request message using the generated form.
  5. Leave Use plaintext on for local and development servers, or turn it off for servers that use TLS.

For a unary call, the response shows the status code, time taken, the response message, and any metadata the server sent back.

Streaming calls show every message as it goes, → Sent or ← Received, and then how the call ended (its status code and name, with the server’s headers and trailers):

  • Server streaming: Send sends the message and the replies arrive one by one.
  • Client streaming and bidirectional: Send opens the call. Then Send message sends the message in the form (edit it and send again as often as you like), and End tells the server you’re done. A bidirectional call’s replies arrive as they come; a client-streaming call’s one reply comes after End.
  • Cancel stops a call at any time.

WebSocket connections

Create a connection with the new connection icon on a WebSocket collection or folder, then enter its URL (e.g. wss://example.com/socket).

  • Set up Auth and Headers as for HTTP requests. Under Subprotocols, list the subprotocols to offer.
  • Click Connect. Type a message and press Enter (or click Send).
  • Sent and received messages appear in a timeline; Clear empties it (the connection stays open).
  • Click Save to keep the connection’s settings, and Disconnect when you’re done.
  • Tests checks the messages as they arrive (see Tests for connections), and with Pro, Mock sets how a mock server answers in its place.

MCP servers

Create a server with the new server icon on an MCP collection or folder.

  • Choose how to reach it:

    • stdio: dialeq starts the server on your computer. Enter the command, its arguments and any environment values it needs.
    • HTTP: enter the server’s URL and any headers it needs.
  • Click Connect. Then:

    • Tools: pick a tool, fill in its arguments and call it.
    • Resources: pick a resource and read it.
    • Prompts: pick a prompt, fill in its arguments and get it.
    • Events: see notifications and connection events; Clear empties the list.

    What a call, read or get returns shows in the Response pane, beside or under the tabs; its Clear empties it.

  • With Pro, Checks checks the server’s tools for poisoning and changes (see Checking MCP servers), and Mock lists the tool results a mock server answers with.

A stdio server runs as a program on your own computer, so only connect to servers you trust.

Messaging connections

Create a connection with the new connection icon on a Messaging collection or folder, and click its kind: MQTT, Kafka, Socket.IO, AMQP (RabbitMQ) or NATS (Cancel closes the dialog). It’s created at once with a default name, such as New MQTT connection, which you can click to rename, and a local address you can change:

Kind Address A channel is
MQTT (3.1.1 or 5) mqtt://, mqtts://, ws:// or wss:// a topic (+ and # wildcards)
Kafka kafka://host:9092 (several brokers comma-separated), kafkas:// for TLS a topic
Socket.IO http(s)://host/namespace an event name (* for all of them)
AMQP amqp:// or amqps://, the vhost as the path a queue, and a routing key when publishing
NATS nats:// or tls:// a subject (* and > wildcards)
  • Auth: a username and password (Basic) for every kind, which Kafka sends with SASL, or a token (Bearer) for NATS and Socket.IO.
  • Settings: the kind’s own options, such as the MQTT version and client ID, Kafka’s SASL mechanism, or Socket.IO’s path and auth payload, and Verify TLS certificates (see TLS certificates).
  • Headers: sent with the connection’s handshake, for Socket.IO and for MQTT over ws:// or wss://.
  • Subscriptions: add a channel with its options (MQTT’s QoS, a Kafka consumer group or reading from the beginning, an AMQP exchange to bind a queue to, a NATS queue group). Subscriptions are saved with the connection and made again each time you connect; ● marks the active ones. If the broker refuses one, the reason shows next to it.
  • Publish: enter the channel and the payload, a key (Kafka) and headers where the kind has them, and its options (QoS and retain, a partition, waiting for a Socket.IO acknowledgement, an AMQP exchange, a NATS request that waits for a reply), then click Publish (or press Ctrl+Enter in the payload). The result, or the broker’s reason for refusing, shows next to it.
  • Timeline: every message sent (↑) and received (↓), with connection events. Filter it by channel, and click a message to see its key, headers, details (QoS, partition and offset, delivery tag…) and payload, with JSON laid out. Clear empties it; the connection stays open.
  • Tests: at the right end of the tabs, as for other connections.

A payload that isn’t text is shown, and can be sent, as base64. A lost connection isn’t reconnected by itself: the timeline shows it ending, and Connect opens it again. Click Save to keep the connection’s settings and subscriptions.


Environments and variables

An environment is a named set of variables, for example Local, Staging and Production. It belongs either to one workspace, or to none: a global environment can be used from every workspace, so settings you share across projects live in one place.

In the IDE Style layout, open the environments panel ({ } in the activity bar), select one and click Use; Stop using goes back to No Environment, and the one in use is marked In use. The command palette has an Environment: … entry for each too. The other layouts also have an environment switcher in the header. It lists No Environment first (the default: no environment’s variables are used), then the open workspace’s environments, then the global ones, marked Global. Type in its search box to narrow the list down by name; the arrow keys and Enter choose too. Its last item, Manage environments…, opens the environments panel (as does { } in the activity bar).

In Manage environments, the workspace’s environments and the global ones are listed apart. + Workspace environment creates one only this workspace can use, + Global environment one every workspace can use. Select one to rename or delete it and edit its variables; changes to a global environment apply in every workspace. The Workspaces view’s Manage environments… opens the same panel for any workspace.

Export saves the selected environment, as last saved, on its own to an environment file (<name>.env.dialeq.json). Import reads it back, here or on another computer, with its Secret boxes ticked, and the command line’s --env-file takes it. If the environment has secrets (variables marked Secret, and ones named like a credential, such as token or password, as an export judges them), you’re asked whether to export their values or their names only.

Tick a variable’s Secret box (then Save) for a password, token or key: its value is masked, and kept to this computer. An export without secrets carries its name only, and so does a shared workspace: everyone sets their own value for it, and getting a new version keeps yours. A secret with no value here says so in the panel.

In requests, write {{variableName}} anywhere: the URL, params, headers, body, auth or GraphQL query. When you send, it’s replaced with the value from the active environment. A variable with no value is left as-is, e.g. {{typo}}, so mistakes are easy to spot.

  • Choosing one: type {{ in a field, and a list of the variables you can use appears (the active environment’s, and the vault’s as vault.name), narrowing as you type. Use the arrow keys and Enter or Tab, or click one, to put it in; Escape closes the list.
  • Opening one: Ctrl+click (⌘+click on a Mac) a variable in a field to open it in Manage environments, on the active environment with its row marked. A variable the environment hasn’t got is added as a new row there, to fill in and save. A {{vault.name}} opens the vault.

Connections use them too: a WebSocket, MCP or messaging connection’s URL, headers, auth and settings when it connects, and what it sends while connected (WebSocket messages, MCP arguments, messaging subscriptions and publishes). The saved connection keeps the {{variables}}, so switching environments points it somewhere else.

Which variables are set shows as you type. In the URL, params, headers, auth, body and SOAP envelope fields, and a connection’s URL and messages, a {{variable}} the active environment sets is green, with a dotted underline, and one it doesn’t set is red, with a wavy underline: it would be sent as written. Hover over the field to see each variable’s value and where it comes from. Switch environments and the colours follow. Password fields aren’t coloured, so their text stays hidden. A variable a pre-request script sets shows as red until then, since it only exists while the request runs.

Scripts can also set variables for a single run (see below).

The vault (Pro)

The vault keeps secrets such as API keys, passwords and tokens encrypted on your computer, protected by your computer login (Windows’ data protection, or the Keychain on a Mac). There’s one vault for dialeq, so the same secret works in every workspace. Open it from Settings → Vault…. It’s part of DIALeQ Pro: without a licence that includes it, the panel says so, Move to vault isn’t offered, and a {{vault.name}} is sent as written.

Adding a secret: click + Add secret, give it a name (letters, digits, _ and -) and its value, and Save. The value box hides what you type; tick Show while typing to check it.

Using a secret: write {{vault.name}} wherever a variable can go, for example Authorization: Bearer {{vault.stripe_key}}. Copy reference puts that on the clipboard for you. The value is filled in only at the moment a request is sent, so requests, environments, exports and history keep {{vault.name}} and never the value. In the colour-coded fields, a secret the vault has shows green (hover: filled in from the vault when sent), and one it doesn’t have shows red.

Seeing and copying a value: the vault lists names, never values. Reveal shows one value for 30 seconds (Hide hides it sooner). Copy value copies it without showing it, and it’s cleared from the clipboard after 30 seconds if it’s still there. The Logs say a secret was revealed or copied, never what it is.

Changing a secret: Edit gives it a new value (leave the box empty to keep the current one). Rename changes its name; if requests, connections or environments in the open workspace (or global environments) use it, you can change them to the new name at the same time. Delete says how many places in the open workspace and the global environments still use it before you confirm.

Moving a variable into the vault: in Manage environments, a variable’s Move to vault stores its value in the vault and leaves {{vault.name}} in the environment, saved straight away. Everything that used the variable keeps working, and the secret no longer goes out with the environment’s exports.

What’s hidden: if a secret’s value (four characters or longer) comes back in a response, a script’s log, a run or load test report, a stream’s messages or history, dialeq shows ••• instead. A test script that copies a secret into the environment saves {{vault.name}}, not the value. Scripts do see the request as it’s sent, secrets included, so a script you write could read one.

The vault stays on this computer: it isn’t exported, and another computer or user account can’t read it. On a new computer, add the secrets again. If your computer can’t encrypt (some Linux setups without a keyring), dialeq won’t keep secrets rather than keep them in plain text.


Pre-request and test scripts

For HTTP, GraphQL and SOAP requests, you can write JavaScript in the Pre-request Script and Tests tabs. It runs before the request is sent or after its response arrives (a SOAP request’s tests see the response envelope as dq.response.body). Scripts use the dq object:

// Pre-request script: runs before the request is sent
dq.variables.token = 'abc123'; // use it in this request as {{token}}

// Test script: runs after the response comes back
dq.test('status is 200', () => {
  dq.expect(dq.response.status).toBe(200);
});

dq.test('body has the right id', () => {
  dq.expect(dq.response.json().id).toBe(42);
});

Checks available on dq.expect(value):

  • .toBe()
  • .toEqual() (deep equality)
  • .toBeDefined() and .toBeUndefined()
  • .toBeNull()
  • .toBeTruthy() and .toBeFalsy()
  • .toBeGreaterThan() and .toBeLessThan()
  • .toContain()
  • .toHaveProperty(key, value?)

Put .not before any check to reverse it, e.g. dq.expect(status).not.toBe(404).

Also available:

  • dq.variables: the active environment’s values, as strings, for this request. Set a value here to use it as {{name}} in this request (its test script sees it too). It lasts only for this request.

  • dq.environment: the active environment itself. A value set here is used by this request too, and is saved to the environment afterwards, so later requests use it, including the next ones in a collection run. delete dq.environment.name removes one. The Logs panel says which values changed (never the values themselves), and a collection run’s summary lists them. With No Environment selected there’s nowhere to save them, so nothing is saved and the log says so.

    // Test script of a login request: keep the token for the requests after it.
    dq.environment.token = dq.response.json().token;
  • dq.cookies: the kept cookies for this request’s address. dq.cookies.get("session") gives a cookie’s value, .has(name) says whether there is one, .toObject() gives them all as { name: value }, and .all() as a list with each one’s domain, path, expiry and flags. In a test script it includes the cookies this response just set.

  • dq.request: the request being sent (read-only: changing it doesn’t change what’s sent; set variables instead).

  • dq.response, in test scripts. It has .status, .statusText, .headers (names in lower case, e.g. headers["content-type"]), .body, .sizeBytes, .timings and .json() to parse the body (it throws if the body isn’t JSON). .timings.durationMs is the total time, and .timings.phases has the breakdown the Timing tab shows: dnsMs, connectMs, tlsMs, waitMs, downloadMs and reusedConnection.

  • console.log(...), and console.info, console.warn and console.error: output appears in the Logs panel.

The sample workspace has examples of all of these, in its Pre-request scripts and Scripts & tests folders.

Test results appear on the response’s Tests tab as a pass/fail list.

Tests for connections

WebSocket and messaging connections have a Tests tab too, and an SSE request’s Tests tab works the same way. There, the script checks the messages the connection has sent and received so far, dq.messages, oldest first. Each has:

  • direction: "sent" or "received"
  • channel: the topic, queue, subject or event name (messaging), or the event’s type (SSE)
  • data: the message as text, and json() to parse it
  • at: how many milliseconds after the connection opened it came
  • key and headers, for messaging protocols that have them
dq.test('an order is paid within 5 s', () => {
  const paid = dq.messages.find((m) => m.channel === 'orders' && m.json().status === 'paid');
  dq.expect(paid).toBeDefined();
  dq.expect(paid.at).toBeLessThan(5000);
});

The tests run again as messages arrive, so the results (under the script, and as a summary on the other tabs) say how the connection is doing so far. Run tests now runs them at once. Only the newest 1,000 messages are checked, and a reconnect starts afresh. dq.request and dq.variables are there too; dq.response isn’t, since a connection has no single response.

Scripts run in a sandbox. Each script runs in its own small JavaScript engine, separate from the app. It can use the dq object and console, and nothing else: no files, no network, no timers, and no access to your other requests or settings. A script that runs longer than 1 second or uses more than 64 MB of memory is stopped, and the error appears in the request’s results.

Even so, only import scripts from people you trust: a script can still read this request’s variables and response. That’s why dialeq doesn’t bring in scripts from shared files unless you ask it to.

Running a collection

Click ▶ Run on any API collection or folder (in the sidebar or its details panel). dialeq runs every HTTP, GraphQL and SOAP request inside it, including sub-folders, in order, using the active environment; SSE and gRPC requests are listed as skipped. You see live progress, then a report:

  • total requests
  • tests passed and failed
  • requests that failed to send
  • total time

The run has its own tab in the bottom panel, Run: name, so you can run several collections or folders at once, each in its tab. Stop in the tab stops a run before its next request; the report then says how many of its requests were sent.

  • One run of each at a time: while a collection or folder’s run is going, its Run buttons are greyed out (hover over one to see where it is running). Stop it in its tab, or let it finish, to run it again. The next run replaces the tab’s results. The same goes for Run with data, Load test and Security checks: clicking one while its tab is open but not running goes back to that tab, with its settings and results.
  • Closing a tab whose run is still going asks first, and stops the run. Switching workspaces closes the runner tabs and stops their runs.
  • Runs at the same time share the workspace: they use the same cookies, and each saves what its scripts change in the environment that was active when it started. If two runs change the same variable, the one that finishes last wins.
  • Only one load test, and one run of security checks, can go at a time in the whole app, so they don’t skew each other: starting another says which one is running.

So that long runs stay light, a run keeps the response body of failed requests only: a passing request’s status, headers, timing and tests are kept, and the log’s trace says its body wasn’t. Open the request and send it to see its body again. A run with data keeps no bodies at all; its results and reports never show them.

Running with data (Pro)

With a DIALeQ Pro licence, Run with data in a collection’s or folder’s view (click it in the sidebar to open it) runs every request once per row of test data, or a number of times:

  • A data file: click Choose data file… and pick a CSV file (a header row of names, then a row per pass; commas or semicolons, and values in quotes where they have a comma or a line break) or a JSON file (an array of objects). The first rows are shown before you run.
  • Repeat: the requests run the number of Times you set, with no data.
  • Delay between requests waits that many milliseconds between one request and the next, and Stop at the first failure ends the run at the first request that fails to send or fails a test. Stop ends a run part-way.

In each pass, the row’s values are {{variables}} (above the environment’s values, and never saved to it), and scripts read the pass as dq.iteration (index from 0, count and data); Postman scripts’ pm.iterationData.get(name) and pm.info.iteration work too. What scripts set in dq.environment carries on to the next pass and is saved to the environment afterwards, as in a normal run.

The results show each iteration with its row’s values and each request’s outcome. To keep or share them:

  • Save HTML report… saves a report to open in any browser, attach to a ticket or keep with a build: a summary (passes, requests passed, failed and not sent, tests, and request times: median, 95th percentile and slowest), the failures first, then each pass with its data and every request. It’s a single file that runs nothing and loads nothing, so it opens offline. Open next to “Saved to …” opens it.
  • Save JUnit XML… saves them for a CI system (a test suite per request per iteration), and Save CSV… for a spreadsheet (a row per request per iteration, with a column per data value).

Every report, and the runner, shows who the licence is for and its id (“Licensed to …”): the HTML report at its foot, the JUnit file as each suite’s properties, the CSV file as a last line starting with #.

Baselines

To see what changed since a run you trust, click Keep as baseline after it. Each collection or folder keeps one baseline, in its workspace. Every later run is then compared with it, and the results say:

  • whether the run is worse than the baseline (something newly fails or is missing), no worse or the same;
  • what newly fails, what’s fixed, what’s still failing and which tests newly fail;
  • status changes (200 → 500);
  • requests that got slower or faster: at least 1.5 times the time, and at least 100 ms apart, so quick requests don’t flap;
  • requests or passes added or missing since (the collection or the data changed). A run you stopped isn’t marked down for the passes it didn’t make.

Passes are matched by number, and each request with itself (renaming it doesn’t matter), so compare runs of the same data file (or the same number of times). The HTML report includes the comparison. Keep as baseline again replaces it (it asks first), and Clear baseline removes it. A baseline holds each request’s outcome, status and time, never the responses themselves, and goes when its workspace is deleted or cleared.

Without a licence the icon still opens the runner, which explains what it does and how to add a licence.

Load testing (Pro)

With a DIALeQ Pro licence, Load test in a collection’s or folder’s view (click it in the sidebar to open it) runs its requests with many virtual users at once, to see how a server holds up. Each user goes through the requests in order, again and again, like someone using the app.

Only load-test servers you run or are allowed to test. Many users at once can slow a server down or take it offline. The test runs in dialeq itself, so dialeq can feel slower while a heavy one runs.

The settings:

  • Virtual users: how many run at once (up to 200, or as many as your licence allows: the panel says which).
  • For a time (up to an hour, or your licence’s limit) or a number of rounds per user.
  • Ramp-up: start the users evenly over that many seconds, instead of all at once.
  • Think time between one request and the next, per user.
  • Use a data file: hand out a CSV or JSON file’s rows, one per round, as {{variables}} and dq.iteration (as in running with data).
  • Run pre-request and test scripts (on by default). Turn it off for raw throughput. When they run, a failed test counts as a failed request.
  • Thresholds (optional): the 95th-percentile latency must stay under a number of milliseconds, the error rate (failed or not sent) at or under a percentage, and the throughput at or above a number of requests per second. A test passes when it meets them all.

Each user has its own copy of the environment (what its scripts set carries on for that user, and nothing is saved) and its own cookies, starting from the workspace’s, so a logged-in session works. What the test sets isn’t kept.

While it runs you see the elapsed time, the users running, the requests so far, the requests per second and 95th-percentile latency in the last second, and the errors, with small charts of both. Stop ends it: each user finishes the request it’s in.

A load test measures this computer as well as the server: when it can’t keep up, the latencies include its own delay. While a test runs, it says when this computer is busy (running more than 100 ms late in the last second), and that it’s overloaded once that has lasted 10 seconds. Try fewer users, or turn off scripts, until it stops.

The results show whether it passed, failed (a threshold wasn’t met) or was stopped; each threshold; the throughput, error rate and latency (median, 95th and 99th percentile, slowest); charts over time; a row per request; the status codes and HTTP versions; and the most frequent problems. When this computer was overloaded, the results say so (and the HTML report warns too).

  • Save HTML report… saves it as a single page with charts, like the data runner’s report, and Save CSV… saves the timeline, a row per second. Both are marked with the licence.
  • Keep as load baseline keeps the test for that collection or folder. Later tests are compared with it: throughput, error rate and latency (median, 95th and 99th percentile), overall and per request, where they moved by 10% or more (and by at least 10 ms of latency or half a point of error rate, so small numbers don’t flap). Lower throughput, or higher errors or latency, is worse. It says when the two tests ran with different settings. Clear load baseline removes it. A collection or folder keeps its load baseline apart from its data-run one. A baseline kept by an older version of DIALeQ isn’t compared (its numbers were measured differently): the results say so, and Keep as load baseline keeps a new one.

Checking MCP servers (Pro)

An MCP server’s tools are instructions to an AI model as much as they are functions: the model reads each tool’s description to decide what to do. A description can quietly tell the model to read a secret or keep something from you (“tool poisoning”), and a server can change its tools after you’ve started trusting it. With a DIALeQ Pro licence, the Checks tab of a saved MCP server checks it for you, on a connection of its own (a stdio server’s command runs as it does when you connect). Save the server first: the checks use the saved server.

Run checks does three things, and gives a verdict: Failed (a breaking change, a high finding or a failed call), Passed, with warnings (a changed description or a medium finding) or Passed.

  • The contract: everything the server offers (its tools with their arguments, resources, resource templates and prompts). After a check you trust, click Keep this contract. Later checks then show what changed: breaking changes first (a tool, resource or prompt removed; an argument removed, retyped or made required), then warnings (a changed tool, argument or prompt description, or changed server instructions: read these, since that’s how a changed server slips in new instructions), then additions and the server’s version. Clear kept contract removes it.

  • The scan reads every description the model reads (it never calls a tool) for signs of tool poisoning, each with a severity and the text it matched:

    • High: instructions that override what the model was told or keep things from you (“ignore previous instructions”, “do not tell the user”, <IMPORTANT> tags); files that hold secrets (~/.ssh, .env, cloud credentials); asking to pass on a password, token or key; sending data to an address; asking for the conversation or system prompt; and invisible characters (shown as <U+200B> and the like) or ones that reorder text.
    • Medium: telling the model to use or avoid other tools, long runs of spaces that push text out of view, and encoded blobs.
    • Low: very long descriptions, and tool names that look alike.

    The scan is a set of patterns, so a finding is something to read, not proof, and a clean scan isn’t a guarantee.

  • Call checks: tool calls you list, with what you expect. Only these are ever made. Add call check, choose the tool, give its arguments as JSON ({{variables}} from the environment work, and are filled in first), and what to expect: the output contains a text, the value at a path (such as items[0].id, in the structured output or the text read as JSON) equals a value, it answers within a number of milliseconds, and whether an error is fine. Skip keeps a check without running it. Save call checks keeps them with the server.

Save HTML report… saves the checks as one page (the verdict, what changed, the findings, the calls and the contract), marked with the licence, and Open opens it. Call checks are kept with the workspace on this computer, and go when the workspace is deleted or cleared. A kept contract is also kept with the server itself, for its mock, so it goes with the server into exports and shared workspaces.

Security checks (Pro)

A request’s response has a Security tab that checks what came back for common weaknesses. It sends nothing more: it reads the request as it was sent and the response you already have.

  • Transport: a request over plain HTTP (high when it carried credentials), and credentials in the URL’s query.
  • TLS: a certificate that isn’t trusted, has expired, isn’t valid yet, ends within 30 days or doesn’t name the host, and TLS older than 1.2.
  • Headers: a missing Strict-Transport-Security (or one under six months), X-Content-Type-Options: nosniff, and for HTML pages Content-Security-Policy and protection from framing; CORS that allows any origin with credentials, or the null origin; answers to requests with credentials that shared caches may keep.
  • Cookies: cookies set without Secure, HttpOnly (for session cookies) or SameSite.
  • Disclosure: software versions in headers such as Server, stack traces and database errors in the body, and secrets in the body (private keys, access keys, tokens, password fields).
  • Tokens: JWTs in the request’s credentials or the body that are unsigned (alg: none), never expire or live longer than a day, or carry claims named like secrets.

Each finding shows its severity (high, medium, low), where it is, what was seen (secrets shortened), and what to do about it. Allow this rule stops a rule being reported in this workspace (for something you’ve reviewed); check again under the list turns it back on. The checks are heuristic: a finding is something to look at, and a clean result isn’t a guarantee. Check only APIs you own or are allowed to test.

Checks that send. A collection or folder’s Security checks opens its Security: name tab in the bottom panel. Tick what to check: Access, Input handling and Protocols are ticked to begin with, AI endpoints only when you tick it (it makes model calls, which may cost money). They send only to the scope below, and only requests that don’t change data unless you say so. A folder of WebSocket, MCP or messaging connections offers Security checks too, with the protocol checks only.

Access checks send each request as written, then again with no credentials (Anonymous) and as each other user you add, and show what each got:

  • Scope: the hosts the checks may send to, one per line (api.example.com, *.example.com for its subdomains, localhost:3000). A request to any other host isn’t sent. Nothing runs without a scope.
  • Anonymous sends each request without its auth, credential headers and cookies; it should be refused (401, 403 or 404). A request answered anyway is a finding.
  • Other users each send the requests with their own variables (such as token={{vault.otherToken}}) or their own bearer token or user name and password. Choose what each should get: Should be refused, Should be let in, Let in, but not to the owner’s data (a finding when its answer is the same as the request as written: one user reading another’s record), or Just show what it gets. They don’t use the workspace’s cookies.
  • Only GET, HEAD and OPTIONS requests are sent unless you tick Also send POST, PUT, PATCH and DELETE requests, which may change or delete data. Requests go one at a time, at most five a second, and Stop stops them.

Run checks asks first, naming the hosts and users, then fills in a table of requests by user (each cell the status, and the finding if there is one), with what the answers as written give away below it. When a request as written isn’t let in itself, the others are only shown. The scope and users are kept with the workspace on this computer.

Input handling sends requests made from a spec again with input the spec doesn’t allow, one change at a time, and checks the API refuses each cleanly (a 4xx; for GraphQL, an answer with errors; for SOAP, a fault):

  • From an OpenAPI operation (requests imported from OpenAPI): a body that isn’t JSON, a required field left out, a value of the wrong type, a string longer than its maxLength, a number outside its minimum or maximum, a value not in its list, a field the spec doesn’t have, a very long value where the spec sets no limit, a required query parameter left out, and text for a numeric query parameter. At most 12 a request.
  • GraphQL requests (no spec needed: the query has its variables’ types): a variable of the wrong type, a field the schema doesn’t have, and a query that doesn’t parse. SOAP requests: an envelope that isn’t XML, and an element the operation doesn’t have.

A finding is input let through (2xx), a server failure (5xx), an answer showing a stack trace or a database error, or the unknown field coming back in the answer (it may have been stored). A request is sent as written first; if that isn’t answered 2xx itself, its invalid input isn’t sent. Most bodies go with POST, so tick Also send POST, PUT, PATCH and DELETE requests for them, against a test system: input let through may be stored.

Protocol checks look at what the other protocols accept: an API folder’s GraphQL and gRPC requests, and a connection folder’s connections. Each connection is opened and closed at once; nothing is subscribed, published or called.

  • Transport: a WebSocket, broker, gRPC or MCP connection without TLS to a host other than this computer (high when it carries credentials).
  • TLS: for each TLS connection, the certificate and TLS version, as the Security tab checks them, from a handshake of its own (not through a proxy).
  • GraphQL: introspection answered (medium when it’s answered without credentials too), and “Did you mean” suggestions for a misspelt field.
  • gRPC: server reflection offered.
  • WebSocket and Socket.IO: a connection accepted from a foreign origin (https://origin-check.invalid), and one that sends credentials accepted without them.
  • MQTT, AMQP, Kafka and NATS: a broker that accepts a connection without its user name, password or token (or one with none, away from this computer).
  • MCP servers over HTTP: a handshake that finishes without the headers that carry credentials. MCP servers run as commands (stdio) aren’t checked here; their Checks tab scans them.

AI endpoints send the prompts of a pack you choose to the folder’s AI requests (an HTTP or SSE request whose body is a chat request), each in place of the request’s own prompt, and read the answers. None are built in: a pack is a JSON file you write or are given, chosen with Choose a prompt pack… and kept with the workspace:

{
  "name": "Our checks",
  "prompts": [
    { "id": "echo", "category": "injection", "prompt": "… {{canary}} …", "lookFor": ["text that means it worked"] }
  ]
}
  • Categories: injection, indirect-injection, jailbreak, encoded, system-prompt, other-users-data, credentials or other; it names the finding a hit is reported as. {{canary}} becomes a random token, new each run, that the answer shouldn’t repeat.
  • Where the prompt goes: a {{securityPrompt}} placeholder in the body when there is one; otherwise the chat’s last user message (OpenAI, Anthropic and Gemini formats, and the Responses API’s input) or a prompt, input, query, question or message field. A request with neither isn’t sent.
  • Findings: the canary or the pack’s lookFor text in the answer (the model followed the prompt), eight or more words in a row of the request’s system prompt, one of your secret markers (text an answer must never have, such as a code word you planted in the system prompt; shown masked), and an email address, card number, key or token the request didn’t have.
  • Run checks says how many model calls it will make first. POST is sent for these (only the prompt changes), at most two a second, and only to the scope.

Reports and baselines. After a run, All findings lists every finding of every check, the most severe first. Save HTML report… saves a report (with who it’s licensed to), Save SARIF… a SARIF 2.1.0 file for code-scanning tools, and Keep as security baseline keeps the run’s findings for this collection or folder: later runs mark what’s New since it, and say what’s still there and what’s gone.

Mock servers (Pro)

A mock server answers requests the way your API would, from the response examples you’ve saved: build and test a client before the API exists, while it’s down or rate-limited, or without reaching it at all. With a DIALeQ Pro licence, open a collection or folder and click Mock: its Mock: name tab shows its mock.

Choose a port (0 takes any free one), then Start mock. It serves its HTTP, GraphQL and SOAP requests at the address it shows (http://127.0.0.1:<port>): each request’s URL is a route, with its {{variables}} filled in from the active environment, and a variable left unfilled (or a :id or {id} segment) matching anything. Point your client at the mock’s address with the same path: for a request to {{baseUrl}}/v1/users/{{id}}, where baseUrl is https://api.example.com, the mock answers http://127.0.0.1:<port>/v1/users/7.

Each request gets, in this order:

  1. the example named in an X-Mock-Example header, or with the status in an X-Mock-Status header;
  2. the example that matches it most closely: a route without variables before one with them, then the example with the most of what its Request says must match (its query parameters, headers and body);
  3. the request’s default example, else its first;
  4. what the request last answered, from the history (when it keeps responses);
  5. an answer made from the request’s spec: for a request imported from an OpenAPI spec, its operation’s success response, in a media type the request accepts, with values from the response schema (its examples, defaults and enums first); for a GraphQL request, data shaped like the query, from the endpoint’s schema as last fetched for the schema browser;
  6. otherwise a 501 (the route has nothing to answer with) or a 404 naming the nearest routes.

Settings → API specs… (or API specs: Manage in the command palette) lists the specs the workspace keeps: the OpenAPI specs and WSDLs you imported and the GraphQL schemas fetched for the schema browser, each with how many requests were made from it. View shows its text; Refresh reads it again from the URL or file it was imported from (a spec imported from a file keeps its path) and replaces its text, leaving the requests and examples made from it as they are, so mocks generate answers from the new spec while your requests stay yours. A spec that was pasted, or whose file has moved, can be read from a file you choose (Refresh from a file…), which it then remembers. Text that isn’t a spec of its kind is refused and the old text stays. Delete removes a spec; its requests stay, but mocks no longer generate answers from it.

Every answer says where it came from in its X-Mock-Source header (and X-Mock-Example), and the mock lists each request it answered, with the example it chose; click a request’s name there to open it. Changes to examples apply to the next request; to use another environment, stop the mock and start it again. The mock keeps running while its tab is closed (click Mock again to see it), and stops when you switch workspaces or close the app.

The mock listens only on this computer unless you tick Reachable from other computers; anyone on your network can then read the examples through it. Allow browsers (CORS), on by default, lets a web page on another address call it.

SSE and gRPC: an SSE request’s example made from a stream is replayed: the mock sends its events with the delays they came with (at most a minute each). gRPC requests are served by a gRPC mock started beside the HTTP one, on its own gRPC port (shown under the address with how many methods it serves): each unary method answers with the example whose request message the call has, else its default or first example, else the response message with its defaults; a gRPC example’s body is a template too ({{request.body.id}} reads the call’s message), and x-mock-example or x-mock-status metadata forces one. Streaming methods are served from examples saved from streams: a server-streaming method sends the received messages of the example chosen for its request message, with their delays, then its status; a client-streaming method waits for the client to finish and answers with the example chosen for its last message; a bidirectional method replays the example named in the metadata, else its default or first example, in turn (each received message after its delay, waiting for the client at each message it sent), then answers each further message by the example’s rules, and finishes with its status when the client does. An example of a unary call answers a stream with its one message.

WebSocket connections: a mock of a WebSocket folder serves its connections on the same port, each at its URL’s path (ws://127.0.0.1:<port>/<path>). What it does is set on the connection’s Mock tab: messages to send when a client connects (each after a delay), and rules that reply to what the client sends, the first that matches: When a message has some text (or a /pattern/; empty matches anything), reply with a message, after a delay. A reply can use {{message}} (the message received), {{message.field}} (a value in it, read as JSON) and the request’s values. Fill from this session makes them from the connection’s messages: what arrived before you sent anything is sent on connect, and what arrived after each message you sent becomes its reply. Save mock keeps them.

MCP servers: a mock of an MCP folder stands in for its servers over HTTP, for testing AI agents and clients without the real server: an HTTP server at its URL’s path, a stdio one at /mcp/<its name>. It offers the tools, resources and prompts of the contract its checks kept (Keep this contract), so keep one first. A tool call gets a result you saved: call a tool in the server’s Tools tab and click Save for mocks; a call gets the saved result whose arguments it has (the one with the most of them), else one saved with none, else an error result saying there’s none. The server’s Mock tab lists the saved results, to remove one. Save as call check next to it adds the call to the server’s call checks, expecting what it returned (an error, a value in its structured output, or the start of its text).

Many AI agents start their MCP servers as commands (over stdio) rather than connecting to an address. While a mock of the server’s folder runs, its Mock tab shows the configuration such an agent takes, which starts the command line’s bridge to the mock: dialeq mcp-bridge <the mock's address for it>. Copy it into the agent’s MCP configuration. The bridge passes each message to the mock and writes back its answers; it needs the command line and mock servers in your licence.

Answers that follow the request: an example’s body and headers can take values from the request a mock answers, written in {{ }}: {{request.path.id}} (a path parameter: {{id}}, :id or {id} in the request’s URL), {{request.query.q}}, {{request.headers.X-Tenant}}, {{request.body.user.name}} (a value in a JSON body; {{request.body}} is the whole body), {{request.method}}, {{request.path}} and {{request.url}}; and generated ones: {{$uuid}}, {{$now}} (the time, ISO 8601), {{$timestamp}} (seconds), {{$randomInt}} (0 to 1000) and {{$randomInt(1, 6)}}. Inside a string in a JSON body, a value is escaped for it, so {"name": "{{request.body.name}}"} stays valid JSON. Anything else in {{ }} is left as it is.

For logic a template can’t express, give the request a Mock Script (its tab beside Tests): it runs when a mock answers the request, with dq.request the request it got, dq.variables its path parameters, and dq.response the answer chosen, which it can change: its status, statusText, headers and body, or dq.response.setJson(value). A request with nothing else to answer with can answer through its script alone. A script that fails makes a 500 saying why; scripts have the same limits as test scripts.

Record and replay: give an Upstream (the real API’s address, such as https://api.example.com) and the mock sends on every request it has no close answer for (no example matched it closely, or no route has its path), with the client’s headers, and returns what the API answers (a 502 says why if it can’t be reached). Tick Record what it answers as examples to keep each answer: as an example of the request it matched, or of a new request in a Recorded folder under the collection or folder. The next time, the mock answers from the recording itself, so using your client against the real API once builds a mock you can replay without it. A recorded example keeps the request’s URL, query and body, never its credentials (only its Content-Type and Accept headers).

Delays and faults: Delay from and to make the mock wait a time in that range (in milliseconds, up to a minute) before each answer, and Fail this share of requests answers that percentage of them with an error status instead (X-Mock-Source: fault): for seeing how your client copes with a slow or failing API.

Running a collection from the terminal or in CI

Everything the runners above do, the command line does too, with no window: see The command line and Running in CI.


The command line

dialeq comes with a command line, dialeq, for working from a terminal or a script with no window at all. It runs the requests and tests of an export, and everything the app’s Pro runners do: data-driven runs, load tests, MCP checks, mock servers and security checks. If you only ever use dialeq from the terminal, this section and Running in CI are all you need.

Installing it

  • Windows: the installer puts dialeq on your PATH. Installed from the Microsoft Store or as an MSIX package, it comes as an app execution alias instead, on by default (Settings → Apps → Advanced app settings → App execution aliases turns it off or on). Open a new terminal after installing.
  • macOS: choose Settings → Install ‘dialeq’ command… and enter your password. It’s linked into /usr/local/bin.
  • It also answers to dq: the same command under another name.

It uses the app’s own files, so it needs no Node.js. Check it with dialeq --version.

Its licence

The command line is part of DIALeQ Pro. It uses the licences in Settings → Licence… on the same computer, Pro Personal, Pro Team and Pro Enterprise alike, so there’s nothing to set up beyond turning Pro on in the app. Without a licence that includes the command line, it says so and stops with exit code 1. --help and --version need no licence.

Who it’s licensed to is printed on the error output (so what the command prints stays its own) and goes into its JUnit XML and reports. On a build machine, use dialeq_ci and a CI licence instead.

Sending one request

dialeq GET https://api.example.com/users
dialeq -k POST https://localhost:8443/items

It prints the status, the time it took, the size and the body. -k (or --insecure) skips the TLS certificate check, for testing only; HTTPS_PROXY, HTTP_PROXY and NO_PROXY are followed.

Running an export

dialeq run my-api.dialeq.json --env CI --junit results.xml

Export a collection, a folder or a workspace from the app (Export, with Include scripts ticked), then run it: its requests run in order with their pre-request scripts and tests, and each result is printed as it arrives. Only HTTP, GraphQL and SOAP requests run; the others are listed as skipped. The options:

Option What it does
-e, --env <name> Use one of the file’s environments.
--env-file <file> Variables from a JSON file ({ "name": "value" }), or an exported environment (a .env.dialeq.json file from Manage environments’ Export, or Postman’s).
--var <name=value> Set a variable; repeatable, and it wins over the environment.
--secret <name> A variable whose value is never printed: it shows as ••• in the output and the JUnit XML. Repeatable. Variables the environment marks Secret are hidden the same way.
--folder <name> Only this collection or folder: a name, or "Collection/Folder".
--junit <file> Also write the results as JUnit XML.
--bail Stop after the first request that fails.
-k, --insecure Don’t check servers’ TLS certificates (testing only).
--proxy <url> Send through this HTTP(S) proxy (default: HTTPS_PROXY or HTTP_PROXY); user:password@ in it is the proxy’s login.
--noproxy <hosts> Comma-separated hosts reached directly (default: NO_PROXY).
--cacert <file> Also trust this certificate authority (PEM); repeatable.
--cert <file>, --key <file>, --pass <phrase> A client certificate for servers that ask for one: PEM with its key, or a .pfx/.p12 file holding both, and its passphrase.
-h, --help Show the options.

A value you give as --var vault.name=… fills in a {{vault.name}} in the requests and is never printed, like a --secret. Scripts that change the environment (dq.environment) change it for the rest of the run only; the file isn’t changed.

The Pro commands

Each takes the run options above (--env, --env-file, --var, --secret, --folder, --proxy, --cacert, -k and the rest), and dialeq <command> --help lists its own. Times are written as 30s, 5m, 1h, or a number of seconds.

Data-driven runs (in the app):

dialeq run my-api.dialeq.json --data users.csv --report run.html --baseline base.json
dialeq run my-api.dialeq.json --iterations 10 --delay 200
  • --data <file.csv|.json> runs the requests once per row, each row’s values as variables; --iterations <n> that many times with no data.
  • --delay <ms> waits between passes.
  • --report <file> saves an HTML report, JUnit XML or CSV, chosen by the extension; repeatable.
  • --save-baseline <file> keeps this run; --baseline <file> compares with a kept one and fails when something newly fails or is missing.

Load tests (in the app):

dialeq load my-api.dialeq.json --users 20 --duration 1m --max-p95 500 --max-error-rate 1
  • --users <n> with --duration <time> or --rounds <n>, within the same limits as the app’s (200 users and an hour, or your licence’s).
  • --ramp <time> starts the users gradually, --think <ms> waits between each user’s requests, --data <file> gives each pass a row, and --no-scripts sends without scripts.
  • --max-p95 <ms>, --max-error-rate <%> and --min-rps <n> fail the command past those limits.
  • --report <file.html|.csv>, --baseline <file> and --save-baseline <file> as for data-driven runs. A baseline saved by an older version isn’t compared: the command says so; save a new one. When this computer was overloaded during the test, the command says so.

MCP server checks (in the app):

dialeq mcp-check my-api.dialeq.json --server "Servers/Calculator" --contract calc.json --calls calls.json
  • --server <name> names the MCP server in the export.
  • --save-contract <file> keeps its contract (tools, resources and prompts); --contract <file> compares with a kept one.
  • --calls <file.json> makes tool calls, with what to expect of each.
  • --allow <rule,...> skips scan rules you’ve reviewed; --report <file.html> saves the report.
  • It fails on a breaking change, a serious finding or a failed call.

Mock servers (in the app):

dialeq mock my-api.dialeq.json --port 4010 --grpc-port 4011

It serves the export’s requests from their saved examples, specs, WebSocket rules and MCP servers’ saved results until you stop it (Ctrl+C), printing each request it answers.

  • --port <n> (default 4010; 0 for any free port) and --host <address> (default 127.0.0.1).
  • --grpc-port <n> for its gRPC requests (default 4011).
  • --upstream <url> sends what no example answers closely on to the real API.
  • --delay <ms|min-max>, --fault-rate <%> and --fault-status <code> make it slow or failing on purpose; --no-cors leaves out the CORS headers.
  • --env fills in the routes’ variables and --folder serves one folder.

An MCP server as a command (mcp-bridge):

dialeq mcp-bridge http://127.0.0.1:4010/mcp --header "Authorization: Bearer …"

It makes an MCP server over HTTP (a mock’s, or any other) a stdio one, for an AI agent that starts its MCP servers as commands. It runs until its input ends.

Security checks (in the app):

dialeq security my-api.dialeq.json --scope api.staging.example.com --sarif findings.sarif --baseline findings.json

Check only APIs you own or may test.

  • --scope <host> is where it may send: api.example.com, *.example.com, localhost:3000; repeatable, and required.
  • --checks <access,input,protocol,ai> picks what to check (the first three by default, and ai with --pack).
  • --identities <file.json> names who access checks send as ({"anonymous": true, "identities": [...]}, as the app keeps them; Anonymous alone without it).
  • --pack <file.json> gives the prompts the AI checks send to chat requests (none are built in), and --markers <file> the text an answer must never contain, one per line.
  • --allow-unsafe-methods sends POST, PUT, PATCH and DELETE too (they may change data); --allow <rule,...> leaves out rules you’ve reviewed.
  • --html <file> and --sarif <file> save the report (SARIF 2.1.0, for code scanning).
  • --fail-on <high|medium|low> is the least severe finding that fails it (high by default); with --baseline <file>, only findings the baseline doesn’t have fail it, and --update-baseline rewrites the baseline from this run.

Output, reports and exit codes

Results go to the standard output as they arrive; who it’s licensed to and any problem go to the error output. Baselines, contracts, call lists and reports are files you name, so they can live with your tests. Every command exits with:

Code Meaning
0 Everything ran and passed.
1 Something failed: a test, a limit, a check, a finding at or above --fail-on, or no licence for the command.
2 It couldn’t start: a bad option, or a file it couldn’t read.

When something goes wrong

  • “command not found”: open a new terminal after installing (Windows), or choose Settings → Install ‘dialeq’ command… (macOS).
  • It says Pro isn’t on, or doesn’t include the command: open Settings → Licence… in the app on the same computer and check the licence type and plan there; a licence bought online needs a Check for updates now and then, as the app does by itself.
  • It says a feature isn’t available: this edition, or your organisation’s policy, leaves it out (Diagnostics says which).
  • Variables stay as {{name}}: pick the environment with --env, or give the value with --var.
  • TLS or proxy errors: use --cacert for your own certificate authority, --proxy (or HTTPS_PROXY) for a proxy, or -k to test without checks.

Running in CI

On build machines, use dialeq_ci: the same command line as dialeq, packaged for pipelines on Windows, macOS and Linux runners, with a licence made for build machines. Everything in The command line works the same way: the options, the Pro commands, the reports and the exit codes.

Installing it

Each release has it as a package, installed with npm on the runner (Node.js 22.22 or later; put the release’s version in place of <version>):

npm install -g @dialeq/ci@<version>
dialeq_ci --version

Its licence

A CI licence works only in dialeq_ci; DIALeQ itself turns it away. dialeq_ci looks for one in these variables, in this order:

Variable What it holds
DIALEQ_LICENCE A CI licence’s text.
DIALEQ_LICENCE_FILE The path of a CI licence file.
DIALEQ_CI_KEY A CI key, which each run trades for a licence.

Keep them in your CI system’s secrets, never in the repository.

A CI key (the usual way): create one in your account’s CI keys (Pro Personal has one, Pro Team one plus one for every 5 seats, and a trial one), and give it to the pipeline as DIALEQ_CI_KEY. Each run trades it for a licence that lasts a day, kept for the rest of the job, so there’s nothing to renew. Revoke the key in your account and its pipelines stop within a day. The runner needs to reach DIALeQ’s licensing service (through --proxy and --cacert, or HTTPS_PROXY, if it goes through a proxy). A Pro Team purchase’s owner can make members managers of its CI keys.

An offline CI licence, for a runner that can’t reach the internet: Download offline licence beside a key, and give its text to the pipeline as DIALEQ_LICENCE (or the file’s path as DIALEQ_LICENCE_FILE). It works until what you paid for ends (a one-time purchase’s for a year), even if you revoke the key, and you’re emailed before it ends.

Examples

GitHub Actions, with the results shown as a check and a SARIF upload to code scanning:

- uses: actions/setup-node@v4
  with:
    node-version: 22
- run: npm install -g @dialeq/ci@<version>
- run: dialeq_ci run my-api.dialeq.json --env CI --junit results.xml
  env:
    DIALEQ_CI_KEY: ${{ secrets.DIALEQ_CI_KEY }}
- run: dialeq_ci security my-api.dialeq.json --scope api.staging.example.com --sarif findings.sarif
  env:
    DIALEQ_CI_KEY: ${{ secrets.DIALEQ_CI_KEY }}
- uses: github/codeql-action/upload-sarif@v3
  if: always()
  with:
    sarif_file: findings.sarif

GitLab CI (DIALEQ_CI_KEY as a masked CI/CD variable), with the JUnit report shown on the merge request:

api-tests:
  image: node:22
  script:
    - npm install -g @dialeq/ci@<version>
    - dialeq_ci run my-api.dialeq.json --env CI --junit results.xml
  artifacts:
    when: always
    reports:
      junit: results.xml

Azure Pipelines (a secret variable must be mapped into the step):

- task: NodeTool@0
  inputs:
    versionSpec: '22.x'
- script: |
    npm install -g @dialeq/ci@<version>
    dialeq_ci run my-api.dialeq.json --env CI --junit results.xml
  env:
    DIALEQ_CI_KEY: $(DIALEQ_CI_KEY)
- task: PublishTestResults@2
  condition: always()
  inputs:
    testResultsFormat: JUnit
    testResultsFiles: results.xml

Any shell, with a mock server standing in for the API while the tests run:

npm install -g @dialeq/ci@<version>
dialeq_ci mock my-api.dialeq.json --port 4010 &
MOCK=$!
dialeq_ci run my-api.dialeq.json --var baseUrl=http://127.0.0.1:4010 --junit results.xml
STATUS=$?
kill $MOCK
exit $STATUS

Tips

  • Fail the build on what matters: every command exits 1 when something fails, which fails the step. Load tests fail past --max-p95, --max-error-rate and --min-rps; security checks at --fail-on.
  • Compare with a baseline: commit the files --save-baseline and --update-baseline write, and pass them with --baseline, so a run fails only on what’s new.
  • Keep secrets out of logs: pass them with --secret or as --var vault.name=…; they print as •••.
  • Proxies and your own certificates: --proxy (or HTTPS_PROXY) and --cacert apply to the requests and to the CI key’s exchange alike.
  • Cache the install: the package is one download per release; cache npm’s folder, or the installed package, keyed by the version.

When something goes wrong

  • It says there’s no licence: set one of the variables above in the step’s environment (a secret isn’t passed to a step unless you map it, in Azure Pipelines for example).
  • It says DIALeQ turns the licence away: a CI licence works only in dialeq_ci, and an ordinary licence only in the app and dialeq.
  • It says the CI key isn’t complete (exit code 2): part of it is missing or mistyped. Copy it again from your account page; nothing was sent.
  • The key is refused: it was revoked, or the purchase lapsed or was refunded; check CI keys in your account. Too many failed exchanges from one address are refused for an hour.
  • The runner can’t reach the licensing service: give it a proxy, or use an offline CI licence.

Importing from other tools

Click the import icon on the API section header to open the Import panel. Paste the content, or click Choose file… to load a file; dialeq detects the file type for you. You can import:

  • Postman Collection: creates a collection with all its folders and requests, including their scripts.
  • Postman Environment: creates an environment with its variables.
  • OpenAPI Spec (3.x, JSON or YAML; a Swagger 2.0 document’s paths too): creates a collection with one request per operation, grouped into folders by tag. Where the spec describes a request body, an example body is filled in, and the response examples it gives become the request’s examples. Path parameters such as /users/{id} become {{id}}. The spec itself is kept with the workspace, so a mock server can answer the operations it has no example for from their response schemas.
  • WSDL (SOAP): paste the service’s WSDL URL (often its address with ?wsdl), or the WSDL itself, or choose a .wsdl file. dialeq creates a collection with a SOAP request per operation: its address, SOAP version, action and an envelope to fill in (see SOAP). From a URL or a file, the schemas and WSDLs it imports are read too; a pasted WSDL’s can’t be, so those types are left as ?, and the panel says so. Each operation’s response message becomes a sample response, the request’s default example, and the WSDL is kept with the workspace.
  • cURL command: paste a curl ... command (for example, copied from your browser’s developer tools). It’s saved, with its method, URL, headers, body and auth, in the Imported from cURL collection (made the first time) as “method host/path”, and opens in its tab.
  • dialeq export: see Sharing your work.

Postman scripts are imported as they are, and most run unchanged: scripts have Postman’s common pm calls too. That’s pm.test and pm.expect, with Chai’s chains such as .to.equal, .to.have.property and .to.be.true; pm.response with .to.have.status(200) and .to.be.ok; and pm.environment, pm.variables, pm.request and pm.cookies. A few Postman calls aren’t available, such as pm.sendRequest (scripts can’t use the network here) and the old postman.* and tests[...] forms. After an import, dialeq lists the requests whose scripts use them, and a script that calls one fails with a message naming it.

Generating code snippets

Open a request’s </> Code tab to see it as ready-to-use code:

  • cURL
  • JavaScript (fetch or axios)
  • Python (requests)
  • Go

Pick a language and click Copy.


Sharing your work

Export your work to an .dialeq.json file to share it with a teammate, keep a backup, or keep it in version control. Exporting the same thing twice gives the same file, so changes are easy to compare.

Exporting

You can export at three levels:

  • One collection or folder: click its name in the sidebar, then click Export in the details panel. An exported folder becomes its own collection in the file.
  • A whole section: click the export icon on the API, WebSocket, MCP or Messaging section header.
  • Everything: Export on a workspace’s card in the Workspaces view exports every collection in all four sections, plus all environments.

The export dialog offers these options:

  • Include secrets (off by default). While it’s off, the file doesn’t contain passwords, tokens, API keys or OAuth client secrets (OAuth access tokens are never in an export). The same goes for any header, param or variable whose name suggests a secret: Authorization, Cookie, or names containing token, secret, key, password, credential or session. A value that is only a {{variable}} is always kept, so your teammate can use their own environment. Secrets typed directly into a request body or a script can’t be detected, so check those yourself, or keep them in the vault: a {{vault.name}} reference is exported, its value never is.
  • Include environments (collection and section exports; off by default). Turn it on and choose which environments to include. A workspace export always includes all environments. Variables marked Secret stay marked: importing the file ticks their boxes again.

Importing

  • Into one section: use the import icon on the WebSocket or MCP section header. For API collections, use the Import panel, choose dialeq export, and paste or choose the file. Only that section’s collections are imported.
  • Everything: Import on a workspace’s card in the Workspaces view (into that workspace), or Import new workspace… there (into a new one).

Nothing is changed until you confirm. First you see a preview of what will be added, with these choices:

  • Import environments (on by default).
  • Import scripts (off by default). Turn this on only for files from people you trust. When it’s off, requests are imported without their scripts.

The preview also warns you about:

  • the commands that imported stdio MCP servers will run on your computer when you connect them
  • secrets that were removed when the file was exported, which you’ll need to fill in
  • requests that refer to files on the exporter’s computer

An import always adds new copies and never changes anything already in your workspace. If a collection or environment with the same name exists, the copy is named e.g. Users API (imported). An import either completes fully or changes nothing.


Settings menu

  • Who you are (at the top): your name and email address, and whether you’re Verified. The edit button by your name opens your details (or, once you’re verified, your display name), and Verify yourself… is there until you are. Switch account… switches to another account verified on this computer, verifies another email or signs out. See Who you are.
  • Invite your friends…: enter up to ten email addresses (and a note, if you like), and dialeq emails each of them an invitation from you. You need to be verified first, since the invitation carries your name; there’s a daily limit, and anyone already invited isn’t sent another. Below the form you see the invitations you’ve sent, and when you can invite each address again.
  • Leave a request…: tell dialeq what you’d like it to do, or do differently. You need to be verified first. Your request goes with your name, the app’s version and this computer’s details, and the panel lists your requests with how each stands (submitted, reviewing, accepted or deferred) and our answer.
  • Cookies…: the cookies dialeq keeps between requests; see Cookies.
  • Network…: the proxy, certificate authorities and client certificates; see Proxy and client certificates.
  • API specs…: the OpenAPI and WSDL specs and GraphQL schemas the workspace keeps for mock servers: view, refresh or delete one; see Mock servers.
  • Vault… (Pro): secrets kept encrypted on your computer and used as {{vault.name}}; see The vault.
  • Verify TLS certificates (on by default; a tick shows it’s on): whether requests check servers’ certificates, unless a request’s own Settings tab says otherwise; see TLS certificates.
  • AI model prices…: the price table dialeq uses to show what an AI API’s answer cost; see Tokens and cost.
  • Licence…: buy DIALeQ Pro online or start a trial, add or remove licences, and see past ones; see DIALeQ Pro.
  • Zoom, on one line as in a browser: − and + change the text size, with the percentage between them (click it to go back to 100%), and the full-screen button turns full screen on or off (also F11). The menu stays open while you zoom, so you can watch the level change.
  • Reload: reloads the window.
  • Install ‘dialeq’ command… (on a Mac, with Pro): puts the command line on your PATH.
  • Diagnostics: shows the dialeq version and system details, and any crash reports. Crash reports are kept on your computer; you can open their folder or clear them from here. If your organisation has turned some of dialeq’s features off (an administrator’s policy on this computer), it lists them: they don’t appear anywhere else, and anything you made with them stays in your workspace, marked, to view, move, export or delete. Send sends them to us, with your details and this computer’s, after you confirm: only when you click it.
  • Help: opens this guide inside dialeq, over the right side of the window (like ? on the activity bar). It works offline. Search the guide at the top (or Ctrl+F, ⌘F on a Mac, while it’s open) finds text in it: every match is highlighted, Enter and ↓ go to the next, Shift+Enter and ↑ to the previous, and Esc clears the search.

Command palette and keyboard shortcuts

Press Ctrl+K (⌘K on a Mac) to open the command palette. Type to search every command, and every saved request, WebSocket connection, MCP server, messaging connection, collection and folder, by name. The letters you type only need to appear in order, so gtus finds Get users. Commands are also found by other words for them: help finds User guide, license or upgrade the licence, dark mode the dark theme, env the environments, feedback Leave a request, and about or version Diagnostics; the word that matched is shown beside the command. Use the arrow keys to pick a result, Enter to run or open it, and Escape to close the palette. Each command shows its shortcut, if it has one.

The shortcuts work anywhere in the window, including while you’re typing in a field or an editor. On a Mac, use ⌘ in place of Ctrl (Ctrl+Tab stays Ctrl+Tab).

Shortcut Command
Ctrl+K or Ctrl+Shift+P Show all commands
Ctrl+Enter Send the open request
Ctrl+S Save the open request, connection or server
Ctrl+N New request
Ctrl+W Close the tab
Ctrl+Tab or Ctrl+PageDown Next tab
Ctrl+Shift+Tab or Ctrl+PageUp Previous tab
Ctrl+B Show or hide the sidebar
Ctrl+J Show or hide the bottom panel
Ctrl+Shift+H Show History
Ctrl+= Zoom in
Ctrl+- Zoom out
Ctrl+0 Actual size
F11 Full screen
F1 This guide

The palette also has commands without shortcuts: closing other or all tabs, keeping a preview tab, showing each sidebar section, managing environments, cookies, API specs, the network settings, the vault, AI model prices and your licence, turning TLS certificate checks on or off, importing and exporting, managing workspaces, clearing the logs or switching trace mode, the themes, and Diagnostics. Under You: are verifying yourself and editing your details.

Trying the sample workspace

The sample workspace is a ready-made set of requests, connections and servers covering everything dialeq can do, with test scripts on every HTTP and GraphQL request. Every request goes to a free public test service, so it works straight away, with no sign-up or keys.

Its Pro — collections show one Pro feature each: a mock server (made from an OpenAPI spec, with examples, a template and a mock script, and WebSocket and MCP mocks), a data-driven run, a load test, security checks, the vault and MCP checks. The sample’s README says how to try each.

Included with the app

Each version of dialeq comes with its own sample workspace. It’s added only if you ask for it: in the installer (Include the sample workspace), in the welcome screen where no installer asked, or in the screen shown after an update. It’s off by default. It appears in the workspace list named for reference, with its version and the day it was added, such as Sample (reference only) · v0.12.0 · installed 2026-10-03, and the environment Sample — httpbin is in it. Adding it doesn’t open it: pick it in the workspace list.

The sample workspace is for reference only:

  • You can add, change and delete anything in it, as in any workspace.
  • Each update replaces it. The old sample workspace is deleted, with everything you changed in it, and the new version’s is added in its place. Nothing from the old one is kept, so keep your own work in another workspace (or copy what you want to keep into one first).
  • If you delete the sample workspace, updates don’t add it again. The screen shown after the next update offers it, or you can import it yourself.

Importing it yourself

  1. Get dialeq-sample-workspace.dialeq.json: every build writes it, with its README, to packages/desktop-client/branded/samples/.
  2. Open Manage workspaces… (the last item in the workspace dropdown), click Import on your workspace’s card, and choose the file. Or click Import new workspace… to keep the sample in a workspace of its own.
  3. In the preview, tick Import scripts, then click Import.
  4. Pick Sample — httpbin in the environment switcher.

It’s added alongside your own work; nothing you already have changes. A sample you import yourself is an ordinary workspace: updates leave it alone.

History

History (its clock icon, at the foot of the activity bar or in the header) lists what you’ve sent, newest first and grouped by day: HTTP, GraphQL, SOAP and gRPC requests, and each connect of an SSE request, a gRPC stream, a WebSocket, an MCP server or a messaging connection, with the messages sent, the MCP tools called (and resources read, prompts got) and the messages published over it. Each shows its status and time (for gRPC, OK or the status code; - where there’s no status, such as a connect or a message). Search by name or URL at the top. Click a request’s entry to open it in a preview tab, as a copy of the request as it was sent, with its response; send it again, or change it first. A connection’s entry shows what was done: what was sent and, for an MCP call or a publish, what came back, with Open connection while the connection is still saved. Hover over an entry and click × to remove it, or click Clear to remove them all.

Settings at the top of History has:

  • Record requests and connections: turn history on or off (it’s on by default).
  • Keep the last … requests: 500 by default; older ones are removed.
  • Store responses: with this off, only each response’s status, time and size are kept, not its body or headers. It applies to HTTP, GraphQL, SOAP and unary gRPC responses, MCP calls’ results and publishes’ results; streams’ incoming messages aren’t kept.

Requests, connections and messages are kept as written, so {{variables}} stay as placeholders and the values from your environments (which can include tokens) aren’t stored. Collection runs aren’t recorded. Like everything else, history stays on your computer.

DIALeQ Pro

DIALeQ is free for any use: with no licence, your licence type is Standard and your plan Standard Free. A Pro licence adds what tests and checks your APIs automatically and repeatedly: data-driven runs with reports and baselines, load tests, MCP server checks, security checks and mock servers; and conveniences: the vault and the command line, with CI. Where the app offers a Pro feature, it’s marked Pro.

The licence plans (compared):

  • Pro Personal: Pro for one person.
  • Pro Team: Pro for a team, a seat for each member, given by email. A Pro Team purchase also adds shared workspaces.
  • Pro Enterprise: for an organisation, on request: volume seats, invoicing and terms to suit.

Settings → Licence… shows your licence type and plan, and everything about your licences.

Buying and managing Pro online

Most people buy Pro online and manage it in their account: there’s no file to keep, and dialeq keeps the licence current by itself. Licences bought online are yours alone, so verify who you are first (Settings → Licence… offers Verify yourself…).

In dialeq (Settings → Licence…):

  • Buy online… opens DIALeQ’s store in your browser: choose a plan, the number of seats, monthly, yearly or a one-time purchase, your country and currency, and see the price as you choose. Pay, and Pro switches on in dialeq by itself.
  • Start a trial (offered while you have no Pro licence; the button says for how many days): Pro Personal free on this computer, once, with nothing to pay and nothing to cancel. A banner says when it’s about to end.
  • Manage online… opens your account in the browser (below).
  • Check for updates fetches your licences again: a renewal, a seat you’ve been given, or a computer freed elsewhere. dialeq also checks by itself when it starts and once a day.

A subscription keeps working offline for a set time after dialeq last checked it; as that time runs out, a banner says so, and going online renews it. A one-time purchase keeps working offline for good, with updates for the months it was bought with. The panel lists the computers each licence is used on, with this computer’s machine ID first.

In your account (the store’s Your account, signed in as the person you verified as):

  • What you bought, or have a seat in: its plan, its billing term, when it’s paid until (or when its updates end), and each seat on one line: Show usage opens how long it works offline and its computers. With more than one, the account shows one at a time: choose another from Licence at the top.
  • A team’s name (a Pro Team or Enterprise purchase): given when it’s bought, and changed by its owners (Rename). The account, receipts and dialeq show it before the purchase’s own name (“Acme Ltd · Pro Team · Monthly”).
  • Owners (a Pro Team or Enterprise purchase): the people who manage it. Owners renew it, give and free seats, manage its CI keys and shared workspaces, and add or remove owners: Add owner with their email address, Remove beside another owner, or Remove yourself to hand it over (each asks first, and there’s always at least one owner). Everyone concerned is told by email. An owner needs a seat only to use dialeq with it; a removed owner keeps a seat they have.
  • A name for a purchase (optional, its owners only): Name your licence and Save name, such as “Payments team”. The account, and dialeq for everyone with a seat in it (after their next Check for updates), show it instead of the plan and term (“Pro Team · Monthly”). Clear it to go back to that.
  • Purchase history (its owners): when it was bought and each renewal, with the amount, and any free extension it was given; any owner downloads its receipts, whoever paid.
  • Renew a purchase: the button is beside its date, highlighted once the renewal is due (when the reminder email goes).
  • Cancel the subscription (at the end, and it asks first): it then ends with the time already paid for. Changed your mind? While that time lasts, Re-activate takes the cancellation back (you’re emailed a confirmation): it’s paid until the same date, and Renew extends it.
  • Move to another computer: Release the old computer, then Check for updates in dialeq on the new one. Each seat works on one computer at a time.
  • Pro Team seats: an owner gives a seat to a colleague’s email address (Give a seat), takes one back (Free this seat), and can give one to themselves. The colleague gets an email: they verify themselves in dialeq as that address, then choose Check for updates.
  • CI keys: create, revoke and see the last use of the keys your pipelines run with, and download an offline CI licence for a runner without internet (Running in CI). A Pro Team purchase’s owners can make members managers of its CI keys.
  • Shared workspaces: a Pro Team purchase’s owners give and take away roles in the workspaces they own, as in the app.
  • Email: whether to get reminders (a renewal coming up, a subscription about to lapse, updates ending, a trial ending). Invitations to a seat and notices about what you bought or were given always come.

Pro Enterprise is priced on request: the store’s On request form asks about your team, and DIALeQ gets back to you with a plan and a price.

What every licence has in common

A licence can include all of Pro or some of it. Each of these is a feature of its own: the vault, the command line, data-driven runs, their run reports and run baselines, load tests, their load reports and baselines, MCP checks, security checks and mock servers. Settings → Licence… lists what yours includes and what it doesn’t, and where a feature isn’t included, the app says so instead of offering it. Licences bought online include all of Pro. Shared workspaces are a Pro feature too, used with a Pro Team purchase.

  • The licence is checked on your computer, with its signature. A licence file is never sent anywhere; one bought online is kept current with the store when dialeq checks for updates, as the person you verified as.
  • Perpetual (one-time) licences keep working for good with the versions released until their updates end; a newer version asks for a renewed licence. Subscription and trial licences end on their end date.
  • If a licence isn’t accepted, the panel says why (for example, it’s for another product, it has ended, this version is newer than its updates, or it has been withdrawn).

Who you are

The first time dialeq opens, before the welcome, it asks who you are: once, for as long as you use it. It never learns what you do with dialeq, how much you use it, or anything in your workspaces.

  • Verify yourself: tick the box to agree to the privacy policy, then choose how to sign in: an email link, Google, Microsoft or GitHub. A page opens in your browser. Check that it shows the same code as dialeq (like TFH-RB9), then sign in there; with an email link, open the link in the email, on this computer or another device. dialeq carries on by itself. It waits up to 15 minutes, and Cancel stops it. You need to be online to verify.
  • You need to verify yourself to use dialeq: there’s no Later, so the first time, dialeq opens once you’ve signed in. If you used dialeq before without verifying, it asks you to verify now. Signing out brings you back to this screen.

At the top of the settings menu you see your name and email address, and whether you’re Verified. Until you verify, the edit button by your name changes your name and email address (and, where sharing them is up to you, whether you share them) at any time, and Verify yourself… verifies you. Once you’re verified, your name and email address are the ones you signed in with; the edit button by your name changes the name dialeq shows (empty goes back to the one you signed in with). The command palette has these too (You:).

Switching accounts

Verified with one email address and want to use another? Settings → Switch account… (or You: Switch account in the command palette) lists the accounts verified on this computer, the one you’re using first:

  • Switch makes another one the account you’re using. It needs no sign-in and works offline: each account’s verification is kept on this computer. The switch is noted in that account’s history online once you’re connected.
  • Verify another email… verifies a new one, which becomes the account you’re using and joins the list.
  • Sign out leaves no account in use: dialeq asks who you are again, as the first time, and its Switch to an account on this computer… brings one back.

Your workspaces, collections, environments, history and vault stay as they are, whichever account you use: they belong to this computer (and to your login on it), not to an account. What follows the account:

  • Licences bought online are the account’s that bought them: they count while that account is in use, and dialeq checks for the new account’s when you switch.
  • Shared workspaces: a copy you imported or shared belongs to the account you did it with, and is hidden while another account is in use. If the new account has a role in the same shared workspace, the copy becomes its own, unless it holds changes the other account hasn’t pushed. Switch account lists those first, with Push now; otherwise they wait, hidden, for the other account, and Shared workspaces… names that account’s copy instead of offering Import. Pushes are made in the name of the account in use.
  • Clear sign-in tokens and cookies (ticked to start with) clears the cookies and OAuth 2.0 tokens of every workspace as you switch, so your requests don’t go as the account you switched from.

If two people share this computer, give each their own login on it: the accounts here share everything else on it.

Who you are is kept on this computer, protected against changes made outside dialeq: if its file is edited, or copied to another computer, dialeq asks who you are again. If your organisation has turned this off (an administrator’s policy on this computer), dialeq doesn’t ask, shows nothing of it and sends nothing.

Your data and privacy

  • Everything you create is stored only on your computer.
  • dialeq has no telemetry and never sends your work anywhere. It connects only to the APIs you send requests to.
  • When you verify yourself, or agree to share your details, dialeq sends who you are to its identity service: your name and email address, an id for your account or this installation, dialeq’s version and edition, and this computer’s ID; each change to details you share is sent too, and so is each switch back to an account verified on this computer (once you’re online). Nothing about what you do with dialeq. See Who you are and the privacy policy.
  • A Pro licence is checked on your computer. For licences bought online, checking for updates sends who you are (as verified), this computer’s ID, and its name, system, time zone and locale, so you can tell your computers apart in the store; nothing about how you use dialeq.
  • Leave a request… and Diagnostics’ Send send what you write, or your crash reports, with dialeq’s version and this computer’s details, only when you click them.
  • A shared workspace is the one thing that leaves your computer, and only when you share it or push: its collections, requests, connections, its own environments and response examples go to dialeq’s service, for the people with a role in it. Secrets in the vault, History, cookies and tokens never do.
  • To back up your work or move it to another computer, use Export in the Workspaces view, then Import new workspace… there on the other computer. If you want the backup to include passwords and tokens, turn on Include secrets when you export.
  • Secrets in the vault are encrypted with your computer login and never leave this computer: exports carry {{vault.name}}, even with Include secrets.