Code-first HTTP client. Write requests in .http files. Run them from the terminal, your AI assistant, or a full desktop GUI.

macOS (Homebrew):

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

macOS / Linux (curl):

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

Windows (PowerShell):

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

Manual: Download from Releases.

RawRequest has two components that share the same .http file format and execution engine:

# === Environments ===
@env.dev.baseUrl = http://localhost:3000
@env.prod.baseUrl = https://api.example.com

# === Variables ===
@contentType = application/json

### GET request
GET {{baseUrl}}/users
Accept: application/json

### POST with body
POST {{baseUrl}}/users
Content-Type: {{contentType}}

{
  "name": "Jane",
  "email": "jane@example.com"
}

### Secrets
POST {{baseUrl}}/auth/login
Content-Type: application/json

{
  "password": "{{secret:myPassword}}"
}

### Scripts (pre and post)
@name login
POST {{baseUrl}}/auth/login
Content-Type: application/json

< {
  // Pre-request script
  console.log('Logging in...');
}

{
  "username": "admin",
  "password": "{{secret:password}}"
}

> {
  // Post-response script
  assert(response.status === 200, `Expected 200, got ${response.status}`);
  setVar('token', response.json.token);
}

### Request chaining
@name getProfile
@depends login
GET {{baseUrl}}/profile
Authorization: Bearer {{token}}

### Load testing
@name healthCheck
@load
duration: 30s
users: 50
rampUp: 5s
targetRPS: 200

GET {{baseUrl}}/health

Key syntax:

• ### separates requests
• @name identifies a request for chaining/targeting
• @depends declares dependencies on other named requests
• @env.<env>.<var> defines per-environment variables
• @timeout sets per-request timeout in milliseconds
• {{var}} interpolates variables; {{secret:key}} resolves secrets
• < { } pre-request script; > { } post-response script
• Scripts have access to request, response, setVar(), assert(), console.log()

# Run a named request
rawrequest run api.http -n login

# Use an environment
rawrequest run api.http -n getUsers -e prod

# Set variables
rawrequest run api.http -n createUser -V "username=john" -V "email=john@test.com"

# Output formats: full (default), json, body, quiet
rawrequest run api.http -n getData -o body | jq .

# Skip pre/post scripts
rawrequest run api.http -n getData --no-scripts

# Verbose mode (show request details)
rawrequest run api.http -n login --verbose

Run load tests against named requests from the command line.

# Basic load test — 10 users for 30 seconds
rawrequest load api.http -n healthCheck

# Custom concurrency and duration
rawrequest load api.http -n healthCheck --users 50 --duration 2m

# Rate limiting with ramp-up
rawrequest load api.http -n healthCheck --rps 200 --ramp-up 10s --users 100

# Abort if failure rate exceeds threshold
rawrequest load api.http -n healthCheck --users 50 --fail-rate 0.05

# Adaptive load control
rawrequest load api.http -n healthCheck --adaptive --users 100

# JSON output for CI pipelines
rawrequest load api.http -n healthCheck -o json

Output includes response time percentiles (P50, P95, P99), throughput, error breakdown, and status code distribution.

rawrequest list api.http

rawrequest envs api.http

RawRequest works as an MCP server, letting AI assistants discover and execute your HTTP requests via chat. Uses stdio transport — no ports needed.

rawrequest mcp [--workspace <dir>] [--env <name>]

When a tool's file parameter is omitted, RawRequest automatically searches the workspace:

• One .http file found → used automatically
• Multiple files found → error prompts to specify a file or use list_files
• No files found → error message

Most clients launch MCP servers from your project directory. Since --workspace defaults to . (current directory), you typically don't need it — auto-discovery just works.

Claude Code — project (.mcp.json in project root):

{
  "mcpServers": {
    "rawrequest": {
      "command": "rawrequest",
      "args": ["mcp"]
    }
  }
}

Claude Code — global (~/.claude.json):

{
  "mcpServers": {
    "rawrequest": {
      "command": "rawrequest",
      "args": ["mcp"]
    }
  }
}

Claude Desktop (claude_desktop_config.json):

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

Claude Desktop does not support variable expansion or cwd — an absolute path is required.

GitHub Copilot — VS Code (.vscode/mcp.json):

{
  "servers": {
    "rawrequest": {
      "type": "stdio",
      "command": "rawrequest",
      "args": ["mcp", "--workspace", "${workspaceFolder}"]
    }
  }
}

GitHub Copilot — project-wide (.github/copilot-mcp.json):

{
  "servers": {
    "rawrequest": {
      "command": "rawrequest",
      "args": ["mcp", "--workspace", "${workspaceFolder}"]
    }
  }
}

GitHub Copilot CLI — global (~/.copilot/mcp-config.json):

{
  "mcpServers": {
    "rawrequest": {
      "command": "rawrequest",
      "args": ["mcp"]
    }
  }
}

The MCP server resolves {{secret:KEY}} placeholders using the same encrypted vault as the desktop app. Set up secrets in the GUI first — they work automatically in MCP and CLI modes.

The desktop application provides a full GUI for working with .http files:

• Code editor — CodeMirror 6 with syntax highlighting, folding, linting, and variable diagnostics
• Request execution — Visual response viewer with timing breakdown
• Secret vault — Encrypted secret management with usage tracking
• Request history — Browse and re-run past requests
• Collection import — Import from Postman and Bruno
• Request navigation — Outline panel (⌘ Shift O) and command palette (⌘ P)
• Load testing — Visual load test runner with live progress and result charts

• Go 1.24+
• Node.js 20+
• Wails CLI

cd frontend && npm install && cd ..

# Development mode with hot reload
./scripts/dev-build.sh

# Build only (no dev server)
./scripts/dev-build.sh --build-only

# Backend
go test ./...

# Frontend
cd frontend && npm test

./scripts/build.sh

RawRequest is a single Go binary that operates in multiple modes:

• CLI mode — rawrequest run|load|list|envs executes directly and exits
• MCP mode — rawrequest mcp runs a long-lived stdio server for AI clients
• Desktop mode — the GUI app runs an internal HTTP backend on localhost; the Angular frontend communicates with it

All modes share the same request parsing, execution, scripting, and templating core.

PolyForm Noncommercial License 1.0.0 — see LICENSE