Single Go Binary • Three Seamless Modes

Write requests in .http.
Run them everywhere.

A premium, code-first HTTP client platform. Define outgoing requests and stateful mock APIs side-by-side. Run from a stunning desktop GUI, high-concurrency CLI, or stdio-based AI MCP server.

Download Desktop App Install via CLI

macOS Cask Windows Portable Linux / curl AI Ready

api.http Mixed Mode

# === Environments & Globals ===
@env.dev.baseUrl = http://localhost:8080
@env.prod.baseUrl = https://api.example.com
@contentType = application/json

### 1. Authenticate Outgoing Client Request
@name login
POST {{baseUrl}}/auth/login
Content-Type: {{contentType}}
{
  "username": "admin",
  "password": "{{secret:adminPassword}}"
}
> {
  // JavaScript assertion & variable propagation
  assert(response.status === 200, "Auth failed");
  setVar('token', response.json.token);
}

### 2. Stateful Local Mock Server (SQLite-backed)
@mockinit
< {
  // Setup schema exactly once upon mock server startup
  db.exec("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)");
}

@mock
POST /users
Content-Type: {{contentType}}
< {
  const body = JSON.parse(request.body);
  const res = db.exec("INSERT INTO users (name) VALUES (?)", body.name);

  response.status = 201;
  response.body = { id: res.lastInsertId, name: body.name, stored: true };
}

### 3. High-Concurrency Stress Test Benchmark
@name stressBenchmark
@depends login
@load duration=30s users=50 rampUp=5s rps=200

GET {{baseUrl}}/profile
Authorization: Bearer {{token}}

ONE ENGINE • THREE WORKFLOWS

Seamless Multi-Mode Architecture

RawRequest is compiled as a single Go binary that operates elegantly across three distinct modes depending on where you are working.

1. Desktop GUI Mode

A beautiful visual editor built with Angular and Wails. Experience code-first speed with a premium sidebar outline, fuzzy command palette, silent disk-watchers, keyring credentials, and scroll restoration.

2. Terminal CLI Mode

Run requests directly from your shell or pipelines with rawrequest run. Pipe responses using `-o body` directly to jq, or execute heavy performance tests with rawrequest load.

3. AI MCP Mode

Provide direct stdio Model Context Protocol access to your AI assistants (Claude Desktop, Claude Code, GitHub Copilot). Let AI discover, read, and invoke your `.http` endpoints to resolve real-world tasks.

VISUAL DESIGN

Premium Workspace

Every interface has been refined to look stunning, respond instantly, and provide pixel-perfect layouts.

RawRequest main window editor interface — Integrated CodeMirror 6 editor with environment variables, secrets, response panels, and sidebars

Load test running in GUI — Visual load testing displaying real-time requests-per-second, status breakdowns, and metrics

Load test results analytics — Detailed test execution results displaying RPS charts, latencies percentiles, and errors

STATEFUL PROTOTYPING

SQLite-Backed JS Mock Server

Tired of running mock definitions in another process? Define your mock endpoints in the exact same `.http` file. Any block marked with a @mock decorator becomes a local API route instantly.

With the new @mockinit directive, you can execute database creation and data seeding scripts exactly once at mock server startup, ensuring your standard route mocks remain completely clean.

db.exec(sql, ...args) Execute write schemas (CREATE, INSERT, UPDATE) with full details.

db.query(sql, ...args) Retrieve relational data tables and return clean JSON lists dynamically.

Premium DX: `@mock` requests are excluded from run trigger gutters, command palettes, and outlines to keep your client focus clean, while path-parameter variables automatically bypass linter warnings!

Mock Database Script

### Stateful Mock Endpoint
@mock
GET /users/{{id}}
Content-Type: application/json
< {
  // 1. Retrieve the path parameter directly
  const userId = request.params.id;

  // 2. Query your persistent local SQLite DB
  const user = db.query(
    "SELECT * FROM users WHERE id = ?",
    userId
  )[0];

  // 3. Return a stateful mock response
  if (user) {
    response.status = 200;
    response.body = user;
  } else {
    response.status = 404;
    response.body = { error: "User not found" };
  }
}

Performance Analytics

STRESS BENCHMARKS

Native Concurrency Load Testing

Ensure your APIs can handle real-world scale before shipping. The @load directive lets you run high-concurrency load tests directly from any request definition.

Specify custom RPS caps, concurrent virtual users, duration intervals, and ramp-up curves. Monitor performance live in the GUI or trigger head-less runs directly in terminal configurations.

rawrequest load api.http -n profile --users
                                    100 --duration 30s

Trigger instant CLI load tests with overridden user parameters.

--fail-rate 0.02 --rps 500 Configure failure abort rate thresholds and maximum RPS targets.

AI INTEGRATION

Stdio Model Context Protocol

RawRequest operates as a direct Model Context Protocol (MCP) server. Instead of copy-pasting API structures to your AI assistants, let AI discover and run requests autonomously.

Assistants like Claude Desktop, Claude Code, and GitHub Copilot discover `.http` files in your workspace, fetch variables, and run requests. Secrets are fetched securely from the system keyring.

list_files Scan the current workspace and discover all .http documents.

list_requests Dissect request structures (URL, parameters, dependency chains).

run_request Execute requests and stream responses and timings back to the AI.

list_environments Inspect available environments and their variables for a file.

set_variable Set a session-scoped variable before request execution.

create_request Create a named HTTP request directly in a `.http` file.

update_request Modify an existing named request while preserving file structure.

save_variable Persist a global or environment variable back into the file.

Claude Desktop Config

{
  "mcpServers": {
    "rawrequest": {
      "command": "rawrequest",
      "args": [
        "mcp",
        "--workspace",
        "/absolute/path/to/project"
      ]
    }
  }
}

STEPS TO LAUNCH

Authoring Workflow

How developers write and manage requests without leaving their IDE boundaries.

Draft HTTP Documents

Write standard REST/gRPC actions alongside stateful local `@mock` routes and pre/post JS scripts inside a readable `.http` file.

Bind Environments

Configure different host profiles and inject secure credentials using encrypted system OS keychain variables.

Execute & Automate

Hit triggers via Wails GUI, schedule stress benchmarks in terminal, or let an AI agent invoke stdio MCP commands.

GET STARTED

Installation Guides

Choose the installation path that suits your environment and command workflow.

macOS (Homebrew)

Tap and install the GUI desktop cask instantly:

brew tap portablesheep/rawrequest https://github.com/portablesheep/homebrew-rawrequest
brew install --cask rawrequest

macOS / Linux (curl)

Install the global binary and setup path integrations:

curl -fsSL https://raw.githubusercontent.com/portablesheep/RawRequest/main/scripts/install.sh | bash

Windows (PowerShell)

Run the secure installation command in PowerShell:

irm https://raw.githubusercontent.com/portablesheep/RawRequest/main/scripts/install.ps1 | iex

CLI Mode Examples

Run request suites and pipe the body results dynamically:

# Run specific named request
rawrequest run api.http -n login -e dev

# Extract and pipe body response to jq
rawrequest run api.http -n getUser -o body | jq .

Ready to revolutionize your API client?

Experience code-first speed across GUI, CLI, and AI environments. 100% local, lightweight, and Git-friendly.

Download RawRequest Star on GitHub

Write requests in .http.Run them everywhere.