Installation

Flux ships as a single native binary, no runtime, no Electron, no Node.js required on the host machine.

Download

Go to the latest release on GitHub and download the installer for your platform.

Account

A free account is required to sync collections. Sign up with your email or with GitHub OAuth directly inside the app on first launch. No credit card needed.

System requirements

• Windows: Windows 10 / 11 (x64)
• macOS: 11.0+ (Big Sur or later)
• Linux: Ubuntu 20.04+ or equivalent (GTK 3 required)
• RAM: 30 MB typical, 60 MB peak
• Disk: ~9 MB installer

Quick Start

Send your first request and save it to a collection in under two minutes.

URL Bar & Method

The URL bar is the primary entry point for every request. It supports environment variable interpolation, a method picker, and a one-click Send button.

Method selector

Click the method badge to the left of the URL field. Supported methods:

Environment interpolation

Use {{variableName}} syntax anywhere in the URL. Active environment variables and global variables are resolved at send time.

https://{{baseUrl}}/api/users/{{userId}}

Keyboard shortcuts

Params

Query parameters are managed in the Params tab. They are appended to the URL automatically.

Adding parameters

Click + Add param and fill in a key and value. Toggle the checkbox to include or exclude a parameter without deleting it. The URL bar updates live as you type.

Bulk edit

Switch to Bulk Edit mode to paste a raw query string directly:

page=1&limit=20&sort=createdAt&order=desc

Headers

Add, remove, and toggle HTTP request headers. Smart autocomplete surfaces common header names and values as you type.

Common headers

Header inheritance

Headers defined at the collection or folder level are automatically merged into every child request. A request-level header with the same name takes precedence.

Auth

The Auth tab provides structured authentication configuration so you never have to manually compose Authorization headers.

Auth types

Body

The Body tab opens when the selected method supports a request payload (POST, PUT, PATCH, etc.). Monaco Editor powers all text-based body types.

Body types

JSON

Full Monaco Editor with syntax highlighting, error detection, and inline linting. Press Shift + Alt + F to auto-format.

"name": "Alice",
"age":  30,
"admin": false

GraphQL

Split view with a Query editor and a Variables editor side by side. Both use Monaco with GraphQL language support.

query GetUser($id: ID!) {
  user(id: $id) {
    name
    email
  }
}

Form URL-encoded

Key-value table editor, identical to the Params tab. Encoded as application/x-www-form-urlencoded.

Multipart Form

Supports text fields and file uploads. Each part can be individually named and typed.

Binary

Upload any file from disk. The Content-Type header is inferred from the file extension.

Pre-request Script

JavaScript that runs before each request is sent. Use it to compute dynamic values, set variables, or conditionally modify the request.

Available globals

Example, dynamic HMAC signature

const body    = flux.request.body.raw;
const secret  = flux.env.get("apiSecret");
const sig     = CryptoJS.HmacSHA256(body, secret).toString();
flux.request.headers.set("X-Signature", sig);

Post-response Script

JavaScript that runs after a response is received. Ideal for extracting values from responses and writing them to environment variables for use in subsequent requests.

Available globals

Example, extract JWT after login

const data = flux.response.body;
if (data?.token) {
  flux.env.set("accessToken", data.token);
  console.log("Token saved:", data.token.slice(0, 20) + "...");
}

Extract

The Extract tab provides a no-code UI for pulling values from a response body and storing them in environment variables, no scripting required.

How it works

Response Panel

The Response Panel occupies the right third of the main screen and shows everything Flux receives back from the server.

Status bar

At the top of the panel, three numbers are always visible after a request completes:

Tabs

Body

The Body tab renders the response payload with automatic format detection and syntax highlighting.

View modes

Copy & Save

Click Copy to put the entire body on your clipboard. Click Save to file to write it to disk, useful for binary responses like file downloads.

Headers & Cookies

Inspect every header and cookie the server returned, with one-click copy for any value.

Headers tab

All response headers are shown in a searchable table. Click any row to copy the value. Common headers like Content-Type, Cache-Control, and X-Request-Id are highlighted.

Cookies tab

Cookies set by the response (via Set-Cookie) appear here with all attributes: name, value, domain, path, expiry, Secure, and HttpOnly. They are automatically stored in the Cookie Jar for subsequent requests.

Tests

Write and run JavaScript assertions against every response. Tests run automatically after each request and show pass / fail indicators inline.

Writing tests

flux.test("Status is 200", () => {
  expect(flux.response.status).toBe(200);
});

flux.test("Body has id", () => {
  const body = flux.response.body;
  expect(body).toHaveProperty("id");
  expect(typeof body.id).toBe("number");
});

flux.test("Response time under 500ms", () => {
  expect(flux.response.responseTime).toBeLessThan(500);
});

AI-generated tests

Click Generate Tests in the Body tab. Flux sends the response schema to Claude, which returns a full set of meaningful assertions. The generated code is placed directly in this editor, ready to run.

Test suite integration

Tests saved per-request are also visible and runnable from the Collection Runner and from the Tests screen in the NavRail.

Timeline

A waterfall view of the request lifecycle, broken into phases so you can identify exactly where time is spent.

Phases

Console

All console.log calls from Pre-request and Post-response scripts appear here, along with any script errors.

Log levels

Script errors (syntax, runtime, uncaught exceptions) are always shown in red with a stack trace.

Collections

Collections are folders of requests stored as plain YAML on disk. Every collection maps directly to a directory tree, commit them to Git and collaborate without any Flux-specific tooling.

Collection structure

my-api/
  flux.yml            # collection metadata
  auth/
    login.yml
    refresh.yml
  users/
    list-users.yml
    create-user.yml

Request YAML schema

name: Create User
method: POST
url: {{baseUrl}}/api/users
headers:
  Content-Type: application/json
  Authorization: Bearer {{accessToken}}
body:
  mode: json
  raw: '{"name":"Alice","email":"alice@example.com"}'
kind: http

Mixed HTTP and gRPC collections

Collections support both HTTP and gRPC requests in the same folder. gRPC requests include an extra kind: grpc field and a grpc: block. Clicking a gRPC request in the sidebar automatically navigates to the gRPC screen.

Collection Runner

Select a collection in the sidebar and click Run Collection. The runner executes all requests in sequence, shows pass/fail for each test, and produces a summary report. Currently supports HTTP requests, gRPC runner is on the roadmap.

Import

Flux can import collections from Postman v2.1 and OpenAPI 3.0. Go to File → Import or drag a file onto the sidebar.

Environments

Environments hold key-value variable sets that are injected into requests at send time. Switch between environments instantly without editing any request.

Variable scopes

Creating an environment

Secret variables

Mark a variable as Secret (lock icon) to mask its value in the UI. Secret variables are stored in the OS keychain and excluded from exports and GitHub sync.

History

Flux persists every request you send to a local SQLite database. The History screen lets you browse, search, replay, and export your request history.

Searching history

Use the search bar at the top to filter by URL, method, or status code. The search is instant and works fully offline.

Replaying a request

Click any history entry to load its full request (URL, method, headers, body) back into the Request Builder. Click Replay to send it again immediately.

Exporting history

Click Export to download your full request history as a JSON file. Useful for auditing, sharing, or importing into analytics tools.

Clearing history

Click Clear History in the Settings → Data & Privacy section or from the History screen's overflow menu. This action is irreversible.

AI Features

Flux integrates Claude (Anthropic) to accelerate testing, debugging, and body authoring. All AI features are BYOK, your key is stored locally and sent directly to Anthropic.

Setup

Go to Settings → AI & Claude, paste your API key (starts with sk-ant-), and select a model. That's it.

Available models

AI features

Test generation

After any successful response, click Generate Tests. Claude analyzes the response schema and generates a complete test suite covering status codes, field types, required keys, and response time. Generated tests appear directly in the Tests tab, ready to run and save.

AI debug assist

When a request fails (4xx/5xx or connection error), the Debug with AI button appears below the status badge. Clicking it sends the request configuration and error to Claude, which returns a plain-English diagnosis and suggested fixes.

Smart autocomplete

With Smart Autocomplete enabled, Flux suggests completions for header names, path segments, and JSON body fields as you type. Suggestions are ranked by frequency and contextual relevance.

Body editing

Right-click inside any Monaco body editor to access Edit with AI. Type a natural language instruction (e.g., "add a nested address object" or "convert this array to paginated format") and Claude rewrites the body in place.

GitHub Sync

Connect a GitHub repository to push and pull collections automatically. Teams use this to share a single source of truth for API requests without any proprietary cloud backend.

Connecting a repository

Auto-sync

Enable Auto-sync on launch to pull the latest version from GitHub every time Flux starts. Changes you make locally are queued and pushed when you click Sync.

gRPC

Flux has a dedicated gRPC screen with support for proto files, server reflection, unary invocations, metadata, and a persistent proto library.

Getting started

Click the gRPC icon in the NavRail (grid of squares). The screen is split into a left panel (service browser) and a right panel (invocation and response).

Loading a proto

Import .proto file

Click Import Proto and select a .proto file from disk. Flux compiles it into a FileDescriptorSet using the embedded protoc and lists all services and methods in the left panel.

Server reflection

Enter the server address and click Reflect. If the server exposes the gRPC Reflection API, Flux fetches all service descriptors automatically, no proto file needed.

Proto Library

Click the Bookmark icon next to a loaded proto to save it to the Proto Library. Saved protos persist on disk across sessions in {app_data}/protos/ and appear in the Library section at the bottom of the left panel. Click any saved proto to reload it instantly.

Invoking a method

Stream types

Saving to a collection

Click Save to Collection in the top-right of the gRPC screen. The request is saved as a YAML entry with kind: grpc. Clicking it in the Collections sidebar navigates back to the gRPC screen with the request loaded.

WebSocket

The WebSocket screen lets you open persistent bidirectional connections and send and receive messages in real time.

Connecting

Message log

All sent and received messages appear in a scrollable log. Received messages are shown with a left indicator; sent messages with a right indicator. Each entry shows timestamp, direction, and byte count.

Sending messages

Type a message (plain text or JSON) in the composer at the bottom and press Enter or click Send. Click Disconnect to close the connection.

Server-Sent Events

The SSE screen connects to event streams and displays each event in real time, useful for monitoring push notifications, live data feeds, and AI streaming endpoints.

Connecting

Enter an http:// or https:// URL that returns text/event-stream, add any required headers (e.g., Authorization), and click Connect.

Event log

Each SSE event appears as a row in the log showing its event type, id, and data. The data field is auto-formatted if it contains JSON.

Filtering

Use the event type filter to show only specific event types (e.g., only update events, ignoring ping events).

Export

Click Export to download all received events as a newline-delimited JSON file for offline analysis.

Load Test

Fire a configurable number of concurrent requests against any endpoint and see latency distribution, throughput, and error rates in real time.

Configuration

Results

After the run completes, Flux shows:

• Throughput, requests per second
• Success rate, percentage of 2xx responses
• P50 / P95 / P99 latency, percentile breakdown
• Latency histogram, bucketed bar chart (<50ms, 50–100ms, 100–250ms, 250–500ms, 500ms–1s, >1s)
• Error count, total failed requests with status codes

Mock Server

Run a local HTTP server that returns predefined responses, ideal for frontend development when the real API is unavailable or not yet built.

Creating a mock route

Response configuration

Request log

Every request the mock server receives appears in the log panel with timestamp, method, path, and matched route. Unmatched requests return 404 and are logged in red.

Compare

Send the same request against multiple environments simultaneously and compare the responses side by side.

How it works

Use cases

• Regression check: Verify that staging and production return identical responses after a deploy
• Migration validation: Compare old and new API versions endpoint by endpoint
• Multi-region testing: Hit us-east, eu-west, and ap-south in one shot

CLI

The Flux CLI lets you run collections, single requests, and tests from the terminal, ideal for CI/CD pipelines.

Installation

The CLI is bundled with the desktop app. After installing Flux, add it to your PATH from Settings → CLI Tools → Add to PATH.

Commands

# Run an entire collection
flux run ./my-api --env production

# Run a single request file
flux run ./my-api/users/create-user.yml --env staging

# Run and output results as JSON (CI-friendly)
flux run ./my-api --env production --reporter json > results.json

# List all collections
flux collections list

Exit codes

All Settings

Open Settings from the gear icon in the NavRail (or Ctrl + ,). Settings are organized into sections accessible from the sidebar.

General

AI & Claude

Appearance

Choose between Dark (default), Light, and System themes. The accent color is always Flux Purple (#A855F7).

Keyboard Shortcuts

Proxy & Network

Route Flux traffic through an HTTP or SOCKS5 proxy. Useful for corporate environments, VPNs, or traffic inspection tools like Charles or mitmproxy.

Proxy configuration

Cookie Jar

Flux maintains a persistent cookie jar. Cookies set by responses are automatically sent with subsequent requests to the same domain.

Viewing cookies

Go to Settings → Cookie Jar to see all stored cookies grouped by domain. Each entry shows name, value, path, expiry, Secure, and HttpOnly flags.

Managing cookies

• Click the delete icon on any row to remove a single cookie.
• Click Clear All Cookies to wipe the entire jar.
• Cookies with an expired Expires date are automatically excluded from requests.

Per-request control

To disable cookie sending for a specific request, add the Cookie header manually with an empty value, or use the Pre-request Script to delete specific cookies before sending.

Data & Privacy

Flux stores all data locally. This page explains what is stored, where, and how to delete it.

What Flux stores

Deleting your data

• Clear history: Settings → Data & Privacy → Clear History
• Clear cookies: Settings → Cookie Jar → Clear All Cookies
• Delete all app data: Uninstall Flux and delete the {app_data}/flux directory

Telemetry

Flux collects anonymous crash reports (via Tauri's built-in crash reporter) to improve stability. No request data, URLs, headers, or response bodies are ever included. You can opt out by toggling Send crash reports in this section.