Open source · MIT License

Open-source API client with built-in AI, Load Testing and Mock Servers.

Built with Rust. Under 30 MB RAM. No Electron. Free account, sign up with email or GitHub.

Download for free View on GitHub
< 30 MB RAM usage
~ 9 MB Installer size
AI · Load · Mock Built in, zero extra tools
— Downloads
MIT License
Flux, API Client
Flux API Client, main request view with AI Test Generator
Why Flux?

What makes Flux different?

Most API clients are Electron wrappers consuming hundreds of MB of RAM. Flux is different and the difference is obvious from the first request.

Performance

Native binary, not a browser wrapper

Most API clients bundle a full Chromium engine and Node.js runtime. Flux is built with Tauri and Rust, a true native binary with no web runtime overhead.

< 30 MB RAM · ~ 9 MB installer
All-in-one

Load testing and mock servers, built in

Other tools need third-party integrations for load testing and mocking. With Flux, both are native features , no extra installs, no Docker, no config files.

AI · Load Testing · Mock Server
Privacy

Local-first, your data stays on your device

Many API clients route your data through their cloud by default. Flux stores everything locally. A free account is required (email or GitHub), cloud sync is opt-in and uses your own Supabase instance, you own your data.

Free account · No vendor lock-in
Audience

Who is Flux for?

Whether you're building APIs, testing them under load, or mocking a backend that doesn't exist yet.

Backend Developers

Test APIs as you write them. AI-generated assertions catch regressions before they reach production.

  • One-click test suite from any response
  • AI debug assist on 4xx and 5xx errors, one-click Apply fixes
  • Environments for dev, staging, production

QA Engineers

Run load tests, validate environments side-by-side, and wire your test collections into CI/CD, with no extra tools.

  • P95/P99 latency reports, no k6 needed
  • Staging vs. production side-by-side diff
  • CLI runner for GitHub Actions and Jenkins

Startup Teams

No subscriptions, no cloud accounts, no vendor lock-in. Spin up a mock server in one click while the backend is still being built.

  • Free account required, sign up with email or GitHub
  • Local mock server, no Docker, no config
  • Open source, self-hostable cloud sync
See it in action

From URL to tested API in seconds

No setup, no config files, no Docker. Open Flux and start testing.

Flux, API Client
One-click fixes

From error to fixed, one click

AI Debug Assist explains the error in Flux terms and offers instant Apply buttons. Click one and the fix is added directly to your request, no copy-pasting, no tab switching.

Flux, API Client
GET
https://api.github.com/users/octocat
Params Headers Auth Body
No headers added
User-Agent : Flux/0.1.5
Response
403 Forbidden
428ms · 252 B
Body Headers Cookies Tests Timeline
Request forbidden by administrative rules.
Make sure your request has a User-Agent header.
AI Debug Assist claude-sonnet-4-6
Screenshots

Every screen, real and live

Click any feature to see the actual interface, no mockups, no illustrations.

About

What is Flux?

Flux is a desktop API client built for speed and simplicity. It runs natively on Windows, macOS and Linux with no Electron overhead. Your data stays local by default, cloud sync is optional and runs on your own Supabase project.

Local-first All data is stored locally on your device. A free account is required to use Flux (email or GitHub). Cloud sync is opt-in and uses your own Supabase project, you own your data.
AI-powered Claude generates test assertions from any response, debugs 4xx/5xx errors, edits your scripts with natural language, and fixes failing assertions.
Native performance Built with Tauri and Rust. Under 30 MB of RAM, 9 MB installer. No Electron, no Node.js runtime bundled, just a native binary.
Full protocol support HTTP, WebSocket, Server-Sent Events and gRPC in one interface. GraphQL schema introspection, OAuth 2.0, AWS SigV4, mTLS, all built in. Import .proto files and invoke gRPC methods without any external tools.
Features

Everything you need

From basic HTTP requests to AI-generated tests, load testing, local mock servers and cloud sync, all in one native desktop app under 30 MB of RAM.

HTTP Requests All methods, auth types and body formats
  • All methods: GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS
  • Body types: JSON, form-urlencoded, multipart/form-data, GraphQL, binary, raw
  • Auth: Bearer token, API Key, Basic, OAuth 2.0 (auth code + client credentials), AWS SigV4
  • Environment variable interpolation with {{VAR}} in URLs, headers and body
  • Pre-request and post-response JavaScript scripts using the pm API
  • Cookie Jar: automatic cookie storage and sending per domain
Collections Organize and run groups of requests
  • Create collections and group requests in named folders
  • Import from Postman v2.1 JSON, OpenAPI 3.x (JSON/YAML), or cURL commands
  • Collection Runner: execute all requests in order with a pass/fail report
  • Per-request test assertions run automatically during the collection run
  • Optional cloud sync: collections saved to Supabase per user
Environments Variables resolved at send time
  • Multiple named environments: Development, Staging, Production and more
  • Global variables shared across all environments
  • Secret keys, masked in the UI, excluded from logs and cloud sync
  • Switch environments instantly from the top bar without changing requests
Tests & Assertions Declarative, no scripting required
  • Declarative assertions, no code needed: status == 200, body.id != null, duration < 500
  • AI-generated assertions: one click after any response generates a full test suite
  • Post-response scripts using pm.test() and pm.expect(), Chai-style API
  • AI fix suggestion when an assertion fails, Apply button applies the fix directly to the request headers or body
  • Batch runner: run all requests in a collection and get a consolidated report
AI Features Powered by Claude, your API key
  • Generate test assertions from any response body with one click
  • Debug assist: structured analysis of 4xx and 5xx errors, what went wrong, root cause, Flux-specific steps, and one-click Apply buttons that add the suggested header, param, or body directly to your request
  • AI script editor: describe what your script should do in plain English
  • Fix failing assertions: Claude proposes a corrected value and an Apply button applies it to the request without leaving the panel
  • Analyze batch test failures across an entire collection run
  • Requires your own Claude API key, added in Settings, never sent to our servers
Important API key required

Flux does not include an API key. You must provide your own Claude API key from Anthropic. It is stored only on your local device and is never sent to Flux servers every AI call goes directly from your machine to Anthropic's API.

Your device
→
Anthropic API
✕
Flux servers

To enable: open Settings → AI & Claude, paste your key (starts with sk-ant-) and choose a model. Get your key at console.anthropic.com/account/keys. Usage is billed by Anthropic directly on your account.

WebSocket Full-duplex client with real-time log
  • Connect to any ws:// or wss:// endpoint with custom headers
  • Send text or JSON messages from a Monaco code editor
  • Timestamped log of all sent and received messages
  • Multiple simultaneous connections open in separate tabs
gRPC Client Protocol Buffers, proto library, mixed collections
  • Import .proto files into a persistent library, reuse them across any request without re-importing
  • Browse full service and method trees from the imported proto; autocomplete on every field
  • Edit payload and metadata in the Monaco editor with JSON syntax highlighting
  • TLS and plaintext transport support, toggle per endpoint
  • gRPC requests live inside collections alongside HTTP requests, mixed collections run in the Collection Runner
  • Saved requests store endpoint, service, method, payload, metadata and the linked proto ID so they reload without manual re-configuration
SSE / Server-Sent Events Stream endpoints in real time
  • Connect to any text/event-stream endpoint
  • Parses event:, data:, id: and retry: fields per the SSE specification
  • JSON data fields are pretty-printed automatically
  • Custom headers for Authorization, API keys and others
  • Cancellable stream, click Stop at any time
Monaco Editor VS Code's editor, embedded
  • Syntax highlighting for JSON, GraphQL, JavaScript and plain text
  • GraphQL schema introspection: autocomplete fields and types from a live endpoint
  • Line numbers, word wrap, bracket matching, all configurable
  • AI script editor overlay: edit scripts with natural language commands
Response Compare Same request, two environments side by side
  • Select any two environments and send a request to both simultaneously
  • Side-by-side diff of status code, response time and body
  • Useful for verifying parity between staging and production
Cloud Sync Your Supabase, you own the data
  • Sign in with email or GitHub, no third-party OAuth lock-in
  • Syncs: collections, environments, request history, app settings
  • Row-Level Security: each user sees only their own data
  • Device-only data (Claude API key, client certificates) is never synced
  • Fully optional, sign in once, then Flux works offline; your data stays local
Local Mock Server 100% offline, zero latency, AI-generated bodies
  • Spin up a localhost HTTP server directly from the app no Docker, no external tools
  • Define endpoints: method, path, status code, response body, content type and artificial delay
  • Wildcard path matching /api/users/* matches any sub-path
  • Hot-reload: add or edit endpoints while the server is running, no restart needed
  • CORS headers injected automatically so any browser or client can connect immediately
  • AI button on every endpoint: Claude generates a realistic JSON body from the method and path context
Load Test Concurrent request runner, no external tools
  • Run any request N times with C concurrent workers no k6, wrk or ab needed
  • Configurable: total requests, concurrency level and per-request timeout
  • Live progress bar showing real-time req/s and average latency as the test runs
  • Final report: min / avg / P50 / P95 / P99 / max latency, throughput and error rate
  • Latency distribution histogram see exactly where the slow tail is hiding
  • Pre-fills URL and method from the current request in the builder
Request Timeline Waterfall breakdown on every response
  • Every response includes a Timeline tab with a proportional waterfall chart
  • Connect + Waiting (TTFB) DNS resolution, TCP handshake, TLS, and server processing time combined
  • Download time to receive the full response body after headers arrive
  • Exact millisecond values for each phase and a summary table with size and status
  • Same level of detail as the Chrome DevTools Network tab, built directly into the response panel
Getting Started

Up and running in minutes

Download Flux, open it, and follow these steps to make your first request and explore the features.

1
Send your first request

Type any URL in the top bar, select a method from the dropdown, and press Ctrl+Enter (or the Send button). The response, status, headers and body, appears in the right panel instantly.

2
Save requests to a collection

Click the + button in the left sidebar to create a collection, then use Ctrl+S to save the current request into it. Organize requests in named folders by dragging them.

3
Use environment variables

Open the Environments tab, create an environment (e.g. Development) and add a variable like BASE_URL = https://api.example.com. Reference it anywhere as {{BASE_URL}}, in URLs, headers and body.

4
Write and run tests

In the Tests tab of any request, add assertions like status == 200 or body.id != null. After sending, each assertion shows pass or fail. Use Generate Tests with AI for a one-click suite from the response.

5
Enable AI features

Go to Settings → AI & Claude, paste your Claude API key (starts with sk-ant-). This unlocks test generation, debug assist on errors, script editing and batch failure analysis.

6
Import existing work

Click the import button in the Collections sidebar to paste a Postman v2.1 JSON, an OpenAPI 3.x spec, or a cURL command. Flux converts it to a collection automatically.

7
Spin up a mock server

Open the Mock Server tab from the left nav. Add endpoints (method, path, status, body), set a port and click Start. Your local server is live at http://localhost:3001 instantly no Docker, no config files.

8
Call a gRPC service

Open the gRPC tab from the left nav. Click the proto library icon to import your .proto file, it stays saved for future sessions. Select your service and method, write the JSON payload, and click Invoke. Save the request to a collection with Ctrl+S to reuse it later alongside HTTP requests.

9
Run a load test

Open the Load Test tab, set total requests and concurrency, and click Run. Watch the live progress bar and see min / avg / P95 / P99 latency, throughput and error rate the moment the test finishes.

Installation

Available for Windows, macOS and Linux

Download the installer for your platform and run it. No dependencies, no runtime, no administrator rights required on Windows.

Windows Flux_x.x.x_x64-setup.exe
  1. Download the .exe installer from the Releases page.
  2. Run the installer and follow the on-screen prompts.
  3. Flux installs to the user folder, no administrator rights required.
  4. Auto-updates run silently in the background when a new version is available.
macOS Flux_x.x.x_aarch64.dmg / x86_64.dmg
  1. Download the .dmg that matches your chip: aarch64 for Apple Silicon (M1/M2/M3), x86_64 for Intel.
  2. Open the .dmg and drag Flux to the Applications folder.
  3. First launch: right-click Flux in Applications and choose Open to bypass Gatekeeper.
  4. Future launches work normally from Spotlight or the Dock.
Linux .deb or .AppImage
  1. .deb, install with: sudo dpkg -i Flux_x.x.x_amd64.deb
  2. .AppImage, make it executable: chmod +x Flux_*.AppImage, then run it directly.
  3. No installation needed for the AppImage, move it to any folder you prefer.
Download latest release All releases
Keyboard Shortcuts

Built for keyboard-first workflows

Every common action has a shortcut. Open the command palette with Ctrl+K to search and discover all available commands.

Send request
Ctrl+Enter
Command palette
Ctrl+K
New tab
Ctrl+T
Toggle sidebar
Ctrl+B
Save to collection
Ctrl+S
Focus URL bar
Ctrl+L
Import collection
Ctrl+O
Duplicate request
Ctrl+D
FAQ

Common questions

Quick answers to what people ask most.

Three reasons, each on its own makes it non-negotiable:

  • Security. If Flux shipped a built-in key, every user would share the same secret. One person decompiling the binary, or a single leaked GitHub commit, would expose it to the entire internet, immediately draining the account. Your own key belongs only to you.
  • Privacy. With your key, every AI request travels directly from your machine to Anthropic's API. Flux never sees your prompts, your response bodies, or what you're testing. If a shared key were used, those calls would have to route through a Flux backend, meaning a third party would process your data.
  • Cost & fairness. The API is not free. Bundling a key would mean Flux pays for every AI call every user makes, which is unsustainable for a free, open-source tool. With BYOK ("bring your own key") you pay Anthropic directly, only for what you use, at the published rate. No subscription, no hidden fees.

How to set it up Open Settings → AI & Claude, paste your key (starts with sk-ant-), and pick a model. Get your key at console.anthropic.com/account/keys.

Your API key is stored only on your local device using the OS secure storage. It is explicitly excluded from cloud sync, even if you sign in to sync your collections, the key never leaves your machine.

Request bodies, response bodies, and everything you send through Flux goes directly from your device to the target server (or to Anthropic when using AI features). Flux has no relay server in the middle.

Flux itself is free. The only cost is what Anthropic charges for the API calls you make, billed directly to your Anthropic account. In practice, typical developer use (generating tests, debugging errors) costs a few cents per month, AI calls in Flux are short, focused prompts, not long conversations.

You can monitor your exact usage at console.anthropic.com/usage. The cheapest model (Haiku) is recommended for everyday use; switch to Sonnet when you need deeper reasoning.

Yes, all core features work without an internet connection: sending HTTP requests, running tests, the mock server, load testing, environment variables, code snippets, and the CLI runner. The only features that require a connection are the AI functions (which call Anthropic's API) and cloud sync (optional).