HTTP Forge 🔨

Free Postman Alternative for VS Code - Build, test, and manage API requests with collections, environments, and advanced scripting support - right in your favorite editor. No account required, no cloud sync, fully offline.

📸 Screenshots

Click any screenshot to open the full-size image.

Feature	Screenshot
Send a Request
Run a Collection
Add Request from Other Collections
Check Result Item
Edit Environment
Import Postman Collection
Import Postman Environment
Response Time Statistics

🆚 Why HTTP Forge over Postman Extension?

🎯 Perfect for developers who:

• Want full offline capability - no internet required
• Need Git version control for API collections
• Work in teams - folder-based storage avoids merge conflicts
• Work in restricted/air-gapped networks
• Prefer local-first tools without cloud sync
• Want privacy - keep API data on your machine
• Already use Postman and want to migrate easily

Migrating from Postman? Just export your Postman collection (v2.1 format) and import it into HTTP Forge!

✨ Features

🔧 Request Builder

• All HTTP Methods: GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD
• Query Parameters: Add, edit, and toggle parameters with ease
• Headers: Custom headers with enable/disable toggles
• Request Body: JSON, form-data, raw text, or no body
  • Mustache template highlighting: Editors highlight full Mustache expressions (variables, sections, partials, comments, and unescaped/triple stache) while preserving Monaco's native syntax highlighting.
• Path Variables: {{variableName}} syntax with automatic substitution
• Pre-request Scripts: Run JavaScript before each request
• Post-response Scripts: Process responses with custom scripts

📁 Collections Management

• Organize Requests: Group requests into collections and folders
• Import/Export: Postman-compatible collection format (v2.1)
• Drag & Drop: Rearrange requests easily
• Collection Runner: Execute entire collections with configurable iterations

🌍 Environment Management

• Multiple Environments: Dev, staging, production, and custom environments
• Variable Substitution: Use {{variableName}} anywhere in your requests
• Environment Inheritance: Share common variables across environments
• Local Secrets: Store sensitive data in gitignored files
• Session Variables: Temporary variables that persist during your session

📊 Response Viewer

• Syntax Highlighting: Beautiful JSON, XML, and HTML formatting
• Response Headers: View all response headers in a table
• Cookies: Inspect and manage cookies
• Metrics: Response time, status code, and response size
• Color-coded Status: Green (2xx), Orange (4xx), Red (5xx)

📜 Request History

• Auto-save: Every request is automatically saved
• Grouped by Context: Organize history by ticket/branch
• Re-execute: Click to restore and re-run past requests
• Delete Entries: Remove individual history items
• Duration Tracking: Color-coded response times

🍪 Cookie Management

• Automatic Handling: Cookies persist across requests
• Domain-aware: Cookies scoped to appropriate domains
• View & Edit: Inspect cookies in the response panel

🧪 Test Suite

• Cross-Collection: Select requests from multiple collections
• Save & Reuse: Save test configurations for QA teams
• Batch Execution: Run selected requests with iterations
• Performance Statistics: P50/P90/P95/P99 response times
• Error Analysis: Error rate and error type breakdown

🚀 Quick Start

1. Install: Search for "HTTP Forge" in VS Code Extensions
2. Open: Click the 🔨 icon in the Activity Bar
3. Create: Click "+" to create a new collection
4. Add Request: Right-click collection → "New Request"
5. Configure: Set method, URL, headers, and body
6. Send: Press Ctrl+Enter or click "Send"

📚 User Guides

Start here: docs/user-guide/index.md

📖 Usage Guide

Creating Your First Request

1. In the Collections view, click the + button
2. Name your collection (e.g., "My API")
3. Right-click the collection → New Request
4. Enter the request name and URL
5. Select HTTP method (GET, POST, etc.)
6. Add headers or body as needed
7. Click Send to execute

Working with Environments

Environments let you define variables for different contexts (dev, prod, etc.):

{
  "dev": {
    "baseUrl": "http://localhost:3000",
    "apiKey": "dev-key-123"
  },
  "prod": {
    "baseUrl": "https://api.example.com",
    "apiKey": "{{API_KEY}}"
  }
}

Use variables in your requests:

• URL: {{baseUrl}}/api/users
• Header: Authorization: Bearer {{apiKey}}
• Body: {"token": "{{sessionToken}}"}

Pre-request & Post-response Scripts

Pre-request Script (runs before the request):

// Set a timestamp
forge.setVariable('timestamp', Date.now());

// Generate random ID
forge.setVariable('requestId', forge.uuid());

Post-response Script (runs after receiving response):

// Extract token from response
const token = forge.response.json().token;
forge.setVariable('authToken', token);

// Validate response
if (forge.response.status !== 200) {
    forge.log('Request failed!');
}

Running Test Suites

Quick Run (single collection):

1. Right-click a collection → Run All
2. Configure iterations and delay
3. Click Run or Save & Run

Create Test Suite (cross-collection):

1. In Test Suites view, click +
2. Select requests from multiple collections
3. Arrange execution order
4. Save for reuse by QA team

Performance Statistics:

• View P50/P90/P95/P99 response times
• Error rate and error breakdown
• Per-request and overall statistics

⚙️ Configuration

HTTP Forge uses a http-forge.config.json file in your workspace root for configuration. This allows you to version control your settings and share them across your team.

Quick Start

Create a http-forge.config.json file in your workspace root:

{
  "$schema": "./node_modules/http-forge/docs/http-forge.config.schema.json",
  "version": "1.0",
  "storage": {
    "format": "folder",
    "root": "./http-forge"
  }
}

Configuration Options

Storage Formats

Folder Format (Recommended)

Each request is stored as a folder with separate files:

• meta.json - Request metadata and headers
• body.json / body.xml / body.txt - Request body

Benefits:

• Git-friendly diffs
• Easy to edit manually
• Better for large request bodies

JSON Format (Legacy)

Collections stored as single JSON files. Simpler but harder to diff.

🔌 Extension API

HTTP Forge exposes a public API for other VS Code extensions:

import * as vscode from 'vscode';

// Get HTTP Forge API
const httpForge = vscode.extensions.getExtension('henry-huang.http-forge');
if (httpForge?.isActive) {
    const api = httpForge.exports;
    
    // Execute a request
    const response = await api.executeRequest({
        method: 'GET',
        url: 'https://api.example.com/data',
        headers: { 'Authorization': 'Bearer token' }
    });
    
    // Get environment variables
    const env = api.getResolvedEnvironment('production');
    console.log(env.variables.baseUrl);
    
    // Open request in tester
    api.openRequest('collection-id', ['folder'], {
        name: 'My Request',
        method: 'POST',
        url: '{{baseUrl}}/api/data'
    });
}

API Reference

⌨️ Keyboard Shortcuts

📋 Requirements

• Visual Studio Code 1.99.3 or higher
• Node.js 18+ (for extension development)

🐛 Known Issues

• Large response bodies (>10MB) may cause performance issues
• Cookie persistence requires workspace trust

Report issues at GitHub Issues

📝 Release Notes

See CHANGELOG.md for detailed release notes.

1.1.0 (2025-01-XX)

• Webview SOLID refactoring - modular architecture with 22 separate modules
• Improved code maintainability and testability

1.0.0 (2024-12-31)

• Initial release
• Full-featured HTTP client
• Collections and environments
• Request history
• Collection runner
• Extension API for integration

🤝 Contributing

Contributions are welcome! Please read our contributing guidelines before submitting PRs.

📄 License

This project is licensed under the MIT License.

Enjoy HTTP Forge! 🔨✨

• Request builder with full HTTP method support
• Collections and folders
• Environment management
• Request history
• Cookie management
• Test Suite with performance statistics
• Postman import/export

Contributing

Contributions are welcome! Please see our contributing guidelines.

License

MIT License - see LICENSE for details.

Enjoy building and testing APIs with HTTP Forge! 🔨