DevTools
Deployable API workflows from real traffic.

Deployable API workflows from real traffic.

Import a HAR → generate a flow → export YAML → run in CI.

Local-first. Git-reviewable. CI-ready.

  • HAR → flow steps + mapping
  • YAML export for PR review
  • CLI reports (JUnit/JSON, exit codes)

CLI: curl -fsSL https://sh.dev.tools/install.sh | bash

Parallel By default
CI outputs JUnit/JSON, exit codes
Local-first No cloud dependency
DevTools main workspace screenshot

A real workspace: flows as files, tabs for runs, diffs before export.

Start from real browser traffic: import a HAR file, DevTools turns it into a replayable API flow with tokens and IDs automatically mapped to variables.

  1. Generated flow
  2. Variables mapped
  3. Export YAML
How it works

Record → Flow → YAML → CI

Quick mental model: visual API workflows with Git‑native YAML export. Flows you can review and run in CI.

Import a HAR file into DevTools

Record real traffic

Capture a HAR from your browser or proxy and drag it into DevTools. We’ll parse requests and auth headers automatically.

  • • Chrome DevTools → Save all as HAR
  • • Sensitive data safe: process happens locally

Build flows automatically

DevTools constructs a visual flow tree and applies Variable Mapping for tokens, IDs, and headers.

  • • Steps generated from your traffic
  • • Automatic variable mapping (repeatable rules)
Flow canvas overview

Map variables and assert

Keep logic in flows, not random scripts. Request editor included, with clear variable mapping and flow‑level assertions.

Learn how flows work

Export to YAML and run in CI

YAML‑native by design: export human‑readable flows for Git review, then run locally or in CI with clear exit codes and reports.

  • • Git‑reviewable flow definitions
  • • CLI reports (JUnit/JSON, exit codes)
CLI JSON report and CI‑friendly output

PR‑ready YAML

Export clean YAML, review in PRs, run in CI with machine‑readable output.

workspace_name: API smoke test
run:
  - flow: Smoke

requests:
  - name: Login
    method: POST
    url: "{{api}}/api/auth/login"
    headers:
      content-type: application/json
    body: '{"email":"{{#env:LOGIN_EMAIL}}","password":"{{#env:LOGIN_PASSWORD}}"}'
    assertions:
      - response.status == 200

  - name: List products (auth)
    method: GET
    url: "{{api}}/api/products"
    headers:
      - name: authorization
        value: "Bearer {{ http_1.response.body.token }}"
        enabled: true
    assertions:
      - response.status == 200

flows:
  - name: Smoke
    steps:
      - manual_start:
          name: Start

      - request:
          name: http_1
          depends_on: Start
          use_request: Login

      - request:
          name: http_2
          depends_on: http_1
          use_request: List products (auth)

environments:
  - name: default
    variables:
      api: https://ecommerce-admin-panel.fly.dev
                
Review in PRs. Run in CI. Machine‑readable outputs.

What you’re seeing

  • Env refs from CI ({{#env:LOGIN_EMAIL}}, {{#env:LOGIN_PASSWORD}})
  • Token chaining between requests (Bearer {{ http_1.response.body.token }})
  • Status assertions on each request
Tabs show the same flow as YAML, and a GitHub Actions snippet to run it.
Roadmap

Scale when you're ready

Run flows locally and in CI for free. When your suite needs more, scale with DevTools Cloud (Roadmap) or self‑host executors.

DevTools Cloud adds

  • • Scheduling
  • • Multi‑region runs
  • • Shared secrets/environments
  • • RBAC + audit log
  • • Hosted executors + autoscaling
  • • Run history + dashboards

Self‑host executors add

  • • Run in your VPC
  • • Your data residency
  • • Your infra control
Comparison

DevTools vs Bruno vs Postman

See how the tooling stacks up when you care about local-first flows, Git-friendly exports, and speed.

Capability / Concern DevTools Bruno Postman
Open source ✅ OSS (desktop + CLI) ✅ OSS ❌ Closed; cloud-centric
Flows (visual + reusable) ✅ Flow trees from HAR; visual builder ❌ No flows ⚠️ Flows available; export limited
HAR → Flow (auto-build from real traffic) ✅ Yes ❌ No ❌ No
YAML export of flows (Git-reviewable) Yes (per-step overrides) ❌ No ❌ No (not for Flows)
Variable mapping (step-scoped, JSONPath) ✅ Automatic, rule‑based (overrides) ⚠️ Basic vars ⚠️ Mixed; often script-heavy
Assertions & evals (flow-level) ✅ Rich assertions at flow level ⚠️ Limited ⚠️ Mixed; tends to rely on scripts
Performance testing & regional locations 🚧 Roadmap (designed pricing) ❌ No ⚠️ Separate add‑ons/monitors
Runner tech & speed Go-based, multithreaded; parallel by default ⚠️ JS runtime; slower at scale ⚠️ Heavier runtime; slower in CI
Local-first / offline ✅ 100% local; no accounts ✅ Local ⚠️ Cloud-first; login + sync
Scripting model ✅ Logic in flows (clean reviews) ⚠️ Limited ⚠️ Often per-request scripts
CI/CD integration ✅ CLI + JUnit/console outputs ⚠️ Basic ⚠️ Possible but heavier, cloud-dependent
Collaboration & dependency ✅ No account required; local‑first ✅ Local; no account ⚠️ Requires account for collaboration; cloud‑dependent features

Benchmark methodology

Internal benchmark executed in Sept 2025 on a MacBook Pro 16” (2023) with Apple M2 Max chip, 32 GB RAM, and macOS Sonoma 14.6.1. Each tool executed the same multipart file-upload request ( api.escuelajs.co/api/v1/files/upload ) using an identical CSV payload.

Tested versions: DevTools v0.0.2, Bruno v2.12.x, and Postman v10.x, all on fresh installs with caches cleared and no proxies or plugins. Each tool performed five warm-up runs and averaged three measured runs on a stable broadband connection.

Representative single-run results: DevTools 133 ms, Postman 313 ms, Bruno 657 ms.

*Measured using app-reported times; real-world results may vary with network conditions and OS background load.