⚡ HTTP Pulse

A fast, beautiful HTTP client that lives inside your .http files.

Run requests with a click, switch environments, use variables, and inspect responses in a polished panel — without ever leaving the editor.

English · Русский

✨ Why HTTP Pulse?

.http files are the easiest way to keep API calls next to your code. HTTP Pulse turns them into a full-featured client:

🚀 Quick start

1. Install the extension from the Marketplace (or press F5 in this repo to run it locally).
2. Create a file with the .http or .rest extension — or run HTTP Pulse: New .http File from the Command Palette.
3. Write a request and press ▶ Run in the CodeLens above it.

@host = https://httpbin.org

### Health check
GET {{host}}/status
Accept: application/json

### Create a user
POST {{host}}/post
Content-Type: application/json

{
  "name": "HTTP Pulse",
  "requestId": "{{$guid}}",
  "sentAt": "{{$isoTimestamp}}"
}

The response opens in a dedicated panel next to the editor — switch between Body, Headers, Request and Timing tabs, copy anything, save the body to disk, or press Run again.

🧰 Request templates

Don't want to start from a blank file? HTTP Pulse ships with ready-made request templates:

• 🆕 HTTP Pulse: New .http File from Template — from the Command Palette or by right-clicking a folder in the Explorer. Pick a scenario, name the file, and it is created with @host and all required variables already declared.
• ➕ HTTP Pulse: Insert Request from Template — from the Command Palette, the editor context menu, or the Add request CodeLens at the top of any .http file. The request is appended to the current file; missing variables are added automatically and existing ones are reused.

Included scenarios: GET with query parameters, GET by id, POST / PUT / PATCH JSON, DELETE, application/x-www-form-urlencoded, multipart/form-data, XML, GraphQL, Bearer token, Basic auth, API-key header, body from a file, webhook and a health check.

📝 File syntax

Requests

Requests are separated with ###. The ### line can also carry a title.

### List users
GET https://api.example.com/users?limit=20
Accept: application/json

### Create user
POST https://api.example.com/users
Content-Type: application/json

{
  "name": "Ada"
}

• # and // start a comment line.
• A request line is METHOD URL [HTTP/1.1]. A bare URL is treated as GET.
• Headers go right after the request line; the body starts after a blank line.
• Long query strings can continue on ? / & lines:

GET {{host}}/search
?q=http%20client
&page=2
Accept: application/json

File variables

@host = https://api.example.com
@token = super-secret

GET {{host}}/me
Authorization: Bearer {{token}}

Environments

Create http-client.env.json next to your .http file (or in any parent folder). Values in $shared are available everywhere.

{
  "$shared": {
    "accept": "application/json"
  },
  "dev": {
    "host": "http://localhost:3000",
    "token": "dev-token"
  },
  "prod": {
    "host": "https://api.example.com",
    "token": "prod-token"
  }
}

🔐 Keep secrets out of version control by using http-client.private.env.json (it overrides the public file and is meant to be git-ignored) with the same structure.

Switch environments from anywhere:

• 🟢 the status bar item (bottom right) while an .http file is active;
• 🧭 the Environment CodeLens at the very top of the file;
• 🏷️ the environment chip in the response panel — click it to change;
• ⌨️ HTTP Pulse: Select Environment in the Command Palette.

The quick pick also lets you open the environment file or create a new one.

🔄 The environment format is the widely used http-client.env.json layout ($shared plus named sections, with an optional http-client.private.env.json), so existing environment files can be reused as-is.

Precedence (highest wins): private environment → public environment → private $shared → public $shared → variables declared in the .http file.

Dynamic variables

Request metadata

Add comment directives inside a request block:

Body from a file

### Upload payload
POST {{host}}/upload
Content-Type: application/json

< ./payload.json

Use <@ ./payload.json to re-indent a JSON file before sending. Variables are resolved inside the included file.

🖥️ Response viewer

The response panel is intentionally dense but readable:

• 🎯 Status & timing — colour-coded status chip, duration, payload size, environment.
• 💧 Timing waterfall — DNS, TCP, TLS, first byte and total.
• 🔍 Full-text filter for large bodies.
• 🌈 JSON highlighting with optional pretty-printing.
• 🖼️ Image preview for image responses.
• 🧾 Request tab — exactly what was sent, including resolved variables and redirect chain.
• 🗂️ History management — search across URLs and names, filter by HTTP method or status bucket (2xx/3xx/4xx/5xx/errors), group entries by method, delete a single response or clear everything. Filters live behind a compact funnel button, so the list stays readable until you need them.
• 📤 Section actions — copy body / save / open live right inside the Body block, copy headers inside Headers, copy URL and cURL inside Request. The top bar now holds only a single Run again chip.

🏗️ Generate requests from ASP.NET Core

Working with a C# or F# ASP.NET Core project? Let HTTP Pulse bootstrap the .http file for you:

• right-click a controller file in the Explorer → HTTP Pulse: Generate .http for Controller;
• right-click inside a controller action → HTTP Pulse: Generate .http for Action;
• or run either command from the Command Palette for the active file.

The generator understands:

• [ApiController] / ControllerBase controllers with [Route], [HttpGet], [HttpPost], [HttpPut], [HttpPatch], [HttpDelete] and route combinations;
• [FromRoute], [FromQuery], [FromBody] and [FromHeader] bindings;
• minimal APIs: app.MapGet(...), MapPost, MapGroup(...), MapMethods, WithName(...);
• the equivalent F# syntax: [<HttpGet>], member _.GetById(id: int), app.MapGet("/x", fun () -> ...) and F# record types.

Routes are combined, converted into {{variables}}, and DTO/record types become JSON skeletons. The result is written next to the source as UsersController.http; existing files are appended, never overwritten.

📮 Export to Postman

Run HTTP Pulse: Export as Postman Collection on any .http file (editor title bar, context menu or Command Palette) to get a Postman Collection v2.1 JSON. Requests, headers, bodies and all file/environment variables are preserved, so {{host}} keeps working after import. Dynamic variables such as {{$guid}} map directly to Postman's own dynamic variables.

🔗 Response scripts & chaining

Add a JavaScript handler after the body to extract values and reuse them in later requests:

### Login
POST {{host}}/login
Content-Type: application/json

{ "email": "ada@example.com", "password": "secret" }

> {%
  client.global.set("token", response.body.token);
%}

### Profile
GET {{host}}/me
Authorization: Bearer {{token}}

Inside the sandbox you get:

• response.status, response.headers, response.body (parsed JSON when possible), response.contentType, response.size;
• request.method, request.url;
• client.global.set(name, value), get(name), isEmpty(), clear([name]);
• console.log/warn/error → output channel.

Variables set by handlers are available immediately in subsequent requests and take precedence over environment and file variables. Scripts run with a 3-second timeout in a restricted sandbox.

🧾 Multipart form-data

Declare fields with # @form, prefix a file value with <:

### Upload
# @form title = Avatar
# @form photo = < ./photo.png
POST {{host}}/api/upload
Content-Type: multipart/form-data

The body is assembled automatically, the boundary is generated, and the Content-Type header is updated — including a proper filename and MIME type for uploaded files.

🖥️ Proxy and client certificates

• httpPulse.proxy routes all requests through an HTTP proxy (CONNECT is used for HTTPS) and supports http://user:password@proxy:8080.
• httpPulse.clientCertificateFile + httpPulse.clientKeyFile + httpPulse.clientCertificatePassphrase enable mutual TLS for HTTPS requests.

💾 Persistent history

Responses are stored in the workspace storage folder (response-history.json), so history survives window reloads. The number of entries follows httpPulse.responseHistoryLimit; bodies larger than 256 KB are not persisted.

⌨️ Commands & shortcuts

Right-click an .http file or the editor for the same actions. Everything is also available in the Command Palette.

⚙️ Settings

🌐 Localization

The extension ships with English (default) and Russian UI. All labels, messages and settings descriptions follow the VS Code display language — no configuration required. Switch VS Code to Russian and the extension interface switches with it.

Manifest strings live in package.nls*.json, runtime strings in l10n/bundle.l10n.*.json.

🧪 Development

npm install       # install dev dependencies
npm run compile   # type-check and build to out/
npm run watch     # incremental build
npm test          # 95 unit tests (parser, variables, cURL, transport, generators, templates, scripts)
npm run verify    # tests + activation/webview smoke tests + localization check
npm run package   # produce a .vsix

🎨 media/logo.svg is the source of the extension icon. The committed icon.png (128×128) and media/logo.png (512×512) are exported from it.

Press F5 to launch an Extension Development Host with the extension loaded.

License

MIT — full text in LICENSE. © 2026 Dmitry Sorokin (dimanrus).