# API Dash: an open source API client for HTTP, GraphQL and AI requests

> API Dash is a Flutter-based API client that runs on desktop and mobile, previews multimedia responses, and generates integration code. The last push to the repository was on 2023-11-29, so treat it as a stable release rather than a fast-moving project.

**foss42/apidash** — API Dash is a beautiful AI-powered open-source cross-platform (Desktop & Mobile) API Client built using Flutter which can help you easily create & customize your HTTP & GraphQL API requests, visually inspect responses and generate API integration code. A lightweight alternative to postman/insomnia.

- Repository: https://github.com/foss42/apidash
- Website: https://apidash.dev
- Stars: 2,915 · Forks: 1,009
- Language: Dart
- License: Apache-2.0
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/foss42-apidash

## What API Dash replaces, and for whom

API Dash is an API client: a GUI where you assemble an HTTP or GraphQL request, send it, and read the response. The README positions it as a lightweight alternative to Postman and Insomnia, and the feature table makes the intended audience fairly narrow. It is for developers who test APIs by hand and want the request definitions to live on their own disk rather than in a synced cloud workspace.

The README states that data is persisted locally on the disk, and that you save a snapshot by pressing the Save button in the collection pane. That single design decision explains most of the product. There is no account, no team workspace and no server-side collection store described anywhere in the README. If your team's workflow depends on shared environments and a central collection that everyone edits, this is the wrong shape of tool.

The second audience is Flutter and Dart developers. The README says the project started as the only open source API client with advanced Dart code generation, aimed at integrating APIs into Dart/Flutter projects or running the generated code on DartPad. Code generation for JavaScript, Python and Kotlin was added later. So the pitch is: build the request once in the GUI, then emit the client code for the language you are actually shipping in.

## How requests, collections and responses move through the app

The architecture visible in the repository is a Flutter application. The top-level entries include lib/, test/, integration_test/, test_driver/, packages/ and a pubspec.yaml, which is the standard layout for a Flutter project with a workspace of local packages. Distribution configuration lives in flutter_launcher_icons.yaml, flutter_native_splash.yaml and distribute_options.yaml, which is how a Flutter codebase produces per-platform installers rather than a single web bundle.

The data flow described in the README is straightforward. You create a request, set the method, and manipulate headers, query parameters and body. Requests are grouped into collections and folders, and you can drag to rearrange them, or rename, duplicate and delete through a popup menu. Responses come back into a previewer that shows the HTTP status code, error message, headers, body and time taken.

The part that stands out is the response previewer. The README claims API Dash can explore, test and preview multimedia API responses, which it says is not supported by any other API client, and lists images, PDF and audio as examples. A Download button saves the response body of any MIME type into the system Downloads folder. That is a real difference from clients that assume every response is text or JSON, and it is the feature most likely to decide whether you switch.

Persistence is file-oriented. A collection or folder can be exported as HAR from its popup menu, which the README notes can be version controlled and imported into other clients such as Postman or Paw. A full export of all data is available under Settings > Export Data. Imports are supported from Postman, cURL, Insomnia, OpenAPI and HAR; hurl is listed as an open issue rather than a supported format.

## Installing API Dash and sending a first request

The README's download table is the place to start, and it is worth reading carefully because most rows do not point at a binary. The iOS and iPadOS build is distributed through the App Store. The macOS .dmg, Windows .exe, Linux .deb, .rpm and Arch PKGBUILD rows all link to doc/dev_guide/setup_run.md, which is the developer setup and run guide, not a release artifact page. There is an INSTALLATION.md at the repository root as well. If you want a packaged desktop build, check whether those links actually resolve to a download before you plan around them; the README does not document a separate release download page.

For a local build, the repository is a Flutter project, so the toolchain is the Flutter SDK. The README does not print the build commands itself, so the following is the conventional sequence for a Flutter app and not a quoted instruction:

```bash
git clone https://github.com/foss42/apidash.git
cd apidash
flutter pub get
flutter run -d macos
```

The -d flag selects the device or desktop target; substitute windows or linux for the other desktop platforms. The documentation in doc/dev_guide/setup_run.md is the authoritative source for the supported targets and any extra system packages.

Once the app is open, the first real use is a request you can inspect end to end. Create a request in a collection, set the method to GET, enter the URL, and send it. The response pane should show status code, headers, body and time taken. If the endpoint returns JSON, XML, YAML, HTML or SQL, the README says you get a formatted code preview rather than raw text. For a multimedia endpoint, the previewer renders the image, PDF or audio directly, and the Download button writes the body into your system Downloads folder.

After the request works, the code generator is the second step. The README describes generating integration code for JavaScript, Python, Kotlin and Dart, with the full list in the repository's Code Generators section. Generated Dart can be run on DartPad according to the README.

## Where API Dash stops: protocols, sync and release cadence

The protocol table is the clearest limitation. HTTP, GraphQL, SSE/streaming and AI requests are marked supported. WebSocket, MQTT and gRPC are listed as GitHub issues, not features. If your day involves a WebSocket debugging session or a gRPC service, this client cannot replace the tool you are using for that work, and the README does not suggest a timeline.

Collaboration is the second boundary. Everything described is local: collections on disk, HAR export for sharing or version control. There is no described mechanism for two people to edit the same collection concurrently, and no hosted sync. Exporting to HAR and committing the file is the documented path, which means merge conflicts are your problem and are resolved in a file format designed for archiving, not for editing.

The third limitation is time. The last push to the repository was on 2023-11-29, and the most recent release listed is v0.3.0 on the same date. That is the release history, and it is the fact to weigh when deciding whether to depend on it. Nothing in the README indicates the project is archived; it also does not indicate recent releases. The README does advertise GSoC 2026 ideas and application discussions, which suggests community activity around the project, but a mentorship program listing is not the same thing as a shipped release.

Two smaller gaps are worth noting. Window size and position persistence is documented as macOS and Windows only, so Linux users lose that. And the AI features, including the DashBot assistant described as powered by a local or cloud LLM, depend on a model you supply or configure; the README does not document the provider list or the configuration keys.

## API Dash against Postman and Insomnia

The README names Postman and Insomnia directly, both as the tools API Dash is an alternative to and as import sources. The difference in approach is where the data lives. Postman and Insomnia are built around accounts and shared workspaces, with local storage as a convenience. API Dash is built around local disk storage, with HAR files as the sharing mechanism. That flips the trade-off: you get no server dependency and no account, and you give up real-time collaboration and any hosted history.

The second difference is the response previewer. The README claims multimedia response preview is not supported by any other API client and lists images, PDF and audio. Postman and Insomnia both handle JSON and text responses well; the multimedia case is where API Dash argues it is different. If you regularly test an endpoint that returns a generated PDF or an image, that claim is the one to verify against your own endpoints before switching.

The third difference is code generation. Postman also generates client code, but API Dash's stated origin is Dart and Flutter, with JavaScript, Python and Kotlin added later. If your team writes Flutter, the generated Dart is the reason to look here rather than at a general-purpose client.

What you cannot conclude from the README is performance or reliability relative to either tool. There are no benchmarks in the README, and none are claimed here.

## Licence, maintenance and what an upgrade costs

API Dash is licensed under Apache-2.0, with the LICENSE file at the repository root. Apache-2.0 is a permissive licence that includes an express patent grant and requires preservation of notices and attribution. It is compatible with commercial use. This is a description of the licence text, not legal advice; if you are redistributing a modified build, read the LICENSE and NOTICE requirements yourself.

For upgrade cost, the practical question is what you are upgrading from. The release history lists v0.1.0 on 2023-03-27, v0.2.0 on 2023-05-04 and v0.3.0 on 2023-11-29. There is a CHANGELOG.md at the root, which is where the per-release detail lives; the README does not summarise breaking changes between these versions. There is also a ROADMAP.md, which is the place to check whether WebSocket, MQTT or gRPC are planned.

Because the app stores data locally, the risk profile of an upgrade is different from a hosted client. Your collections are on your disk, and the documented escape hatch is HAR export under Settings > Export Data. Exporting before an upgrade is the specific step that protects you, since a HAR file imports into Postman, Paw and other clients according to the README. If you build from source rather than installing a package, you also inherit the Flutter SDK version pinned in pubspec.lock, so a Flutter upgrade is part of your maintenance surface.

## Conclusion

Adopt API Dash if you want a small offline API client that previews images, PDF and audio responses and can generate Dart, JavaScript, Python or Kotlin integration code from a request you already built. Skip it if you need WebSocket, MQTT or gRPC support, or if you expect a project that shipped a release in the last two years: the last push was on 2023-11-29. Before committing, verify on your platform that the download link in the README resolves to a real binary or that flutter build works against your Flutter SDK, and confirm which code generators your target language actually has.

## FAQ

### What is API Dash?

It is an open source, cross-platform API client built with Flutter for desktop and mobile. It sends HTTP and GraphQL requests, previews responses including images, PDF and audio, and generates API integration code.

### What does the API Dash platform do?

It lets you create and customize HTTP and GraphQL requests, organize them into collections and folders, inspect responses, and generate integration code for languages including Dart, JavaScript, Python and Kotlin. Data is persisted locally on disk.

### How do I install API Dash?

The README lists an App Store download for iOS and iPad, and points macOS, Windows and Linux users at doc/dev_guide/setup_run.md, which is the developer setup guide for building the Flutter app yourself.

### Which API protocols does API Dash support?

The README marks HTTP, GraphQL, SSE/streaming and AI requests as supported. WebSocket, MQTT and gRPC are listed as open GitHub issues rather than features.

## Sources

- [Official documentation](https://apidash.dev)
- [Official README](https://github.com/foss42/apidash#readme)
- [Project repository](https://github.com/foss42/apidash)
- [Release notes](https://github.com/foss42/apidash/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/foss42-apidash