If you like VS Code REST Client, you’re going to love LAZYREQUEST

Posted on by — No Comments ↓

If you like VS Code REST Client, you’re going to love LAZYREQUEST

You already know the best format for API testing: a plain .http file.

What you probably don’t have is a dead-simple way to run those files from the terminal (and CI), validate the responses you expect, and get a clean PASS/FAIL signal without adopting an entire new testing framework.

Meet LAZYREQUEST: a lightweight, minimal API Testing Client CLI tool inspired by VS Code REST Client syntax. It recursively discovers .http and .rest files, sends the requests, and compares actual responses against the expected responses you declare in the same template.

Site | npm | GitHub

Lazyrequest Terminal UI

If you’ve ever thought:

  • “My API smoke tests should be as easy as writing an HTTP request.”
  • “I want contract-ish checks without standing up a whole test harness.”
  • “Why does ‘try this endpoint’ live in Slack instead of in the repo?”

This is for YOU!.

TL;DR

  • Write requests the same way you already do in VS Code REST Client: method, URL, headers, body.
  • Optionally declare an expected response block right in the file (status + headers + body).

  • Run lazyrequest on a folder. It finds everything, executes fast (concurrent by default), and tells you what broke.

  • No new syntax.

  • No heavy GUI.

  • No learning curve.

  • No Postman tab explosion.

Just .http files. And power.

No collections. No click-ops. No “where did we store the latest curl command?”

The Problem Nobody Talks About

Let’s say you are working on a API and you need to test it, you can quickly write a .http file with something like: 

GET http://localhost:8080/health

You can see it’s output. It works. It’s clean. It’s readable.

But then:

  • You need CI integration

  • You want automated assertions

  • You want folder-wide execution

  • You want concurrent runs

  • You don’t want a browser UI

Suddenly you’re installing a whole testing framework. Yikes…

API Testing: when testing becomes a torture

Most teams already have “API tests” scattered across:

  • random curl commands in docs
  • unreadable Postman collections everybody is affraid to touch
  • a half-finished test suite that only one person understands

LAZYREQUEST makes the happy path boring:

  • your requests live in the repo as .http / .rest
  • your expectations live next to the request (when you want assertions)
  • your terminal becomes the source of truth

A real example (request + expected response)

What If Your .http Files Became Your Test Suite?

That’s exactly what LAZYREQUEST does. 

@baseUrl = http://localhost:8080

###
POST {{baseUrl}}/users HTTP/1.1
Content-Type: application/json

{
  "name": "John Doe",
  "email": "john@example.com"
}

###
# Expected response
HTTP/1.1 201 Created
Content-Type: application/json
Location: {{baseUrl}}/users/123

{"ok":true,"id":123}

Then run: 

$ lazyrequest

And you instantly know:
✓ Passed/Failed Status
✓ Headers correct
✓ JSON structure correct

Or exactly what failed.

Now your repo contains something you can:

  • review in a PR
  • run locally
  • run in CI
  • keep up-to-date without ceremony

Try It. Break It. Star It. ⭐

Installation: 

npm i -g lazyrequest

Or clone + build with Bun: 

git clone https://github.com/FredySandoval/lazyrequest.git
bun build ./src/index.ts --compile --minify --outfile lazyrequest --target bun

Or download the binary from GitHub releases.
https://github.com/FredySandoval/lazyrequest

npm:
https://www.npmjs.com/package/lazyrequest

Final Thought

The best tools don’t invent new syntax.
They unlock the power of what you’re already using.
LAZYREQUEST doesn’t replace your workflow.
It upgrades it. 🚀

Leave a Reply