Requestly: A Lightweight, Git Native API Client That Lives on Your Machine, Not in the Cloud

Mustafa Sayyed — Sat, 28 Mar 2026 08:55:33 +0000

Back in October, I was deep into Hacktoberfest. Like many developers, I was looking for open source projects to contribute to and learn something new. I spent hours browsing repositories, reading issues, and trying to find something that I could work on.

One evening, while scrolling through YouTube, a video from Hitesh Choudhary Sir's Chai aur Code channel popped up. The title was something about "Best API Clients." I clicked out of curiosity. In that video, Hitesh Sir was talking about different API clients he was exploring, and he mentioned that he had recently started using Requestly. He gave a quick demo and suggested viewers give it a try as well.

I had been using Postman for everything up until then. It worked, but I'd started feeling that it was too heavy, too cloud‑focused, and honestly, I wasn't thrilled about storing all my API keys and secrets on someone else's servers. But I hadn't really looked for alternatives. That video was the nudge I needed.

So I went to Requestly's GitHub, checked out the issues, and found a few that seemed beginner‑friendly. I picked one, started contributing, and somewhere along the way, I also started using Requestly for my own projects. Within a week, I had moved all my active work over.

Today, I use Requestly for everything - my personal side projects, open‑source contributions, and even work stuff. Let me walk you through why it stuck with me.

Requestly - a free, open-source API client. It's lightweight, local-first, Git-native, and packed with everything you actually need: collections, environments, scripting, and more.

API Collections: Git-Native Collections That Actually Make Sense

When I first saw how Requestly handles collections, I did a double-take. My collections are just files on my disk. Plain JSON. In Postman, collections lived in the cloud; if I wanted to version them, I had to export a JSON file and commit it manually.

With Requestly, I can store my API collections right inside my project folder. For example, when I'm working on a project, I create a api-collections folder and keep all my request definitions there. Requestly reads them directly from that folder. I can commit them to Git, track changes, review how the API definitions evolve as I add new features, and even roll back if something breaks.

This way, my API requests live right alongside my code. If I clone the repo on a new machine, everything I need - source code and API collections - is already there. No exporting, no manual sync.

This changed how I collaborate. Instead of sending a Postman export file back and forth, we just push changes to the repo. Anyone on the team can clone the project, open Requestly, and they're ready to go. It feels like the API definitions finally belong with the code, not locked away in a separate cloud workspace.

ENVs and Variable Management: My Secrets Stay in My Machine

The thing that bothered me the most about cloud‑based API clients was the constant worry about secrets. I often test APIs that need API keys, session tokens, or even production credentials. Postman stores environment variables in the cloud, and even with "private workspaces", I could never fully shake the feeling that my data was out of my hands.

Requestly fixed this problem. All my environment variables - whether global, collection‑specific, or per‑environment - stay on my machine. Nothing is sent to Requestly's servers unless I explicitly opt into a team workspace (which I rarely do for personal stuff). That means I can store OAuth tokens, database passwords, and secret keys without a second thought.

Here's a real example. I've been building a project called SnapShop - A production-ready e-commerce platform with authentication, payments, and an admin dashboard. When I'm working on it, I have a "Development" environment in Requestly with variables like API_KEY, BASE_URL, and ACCOUNT_ID. The BASE_URL points to http://localhost:5000 when I'm coding locally, but when I need to test the production‑like behavior on staging, I just switch to a different environment, same variables, different values. Everything stays on my machine. No secrets are ever pushed to a cloud server.

When I need to collaborate, I commit the collection to Git, but I .gitignore the actual environment files. Instead, I include an env.example.json file. A collaborator clones the repo, creates their own environment file from the example, and the whole setup stays local on their machine. It's simple, secure, and gives everyone full control.

Scripting and Its Use Cases: Automating the Repetitive Things in API Testing

Scripting is where Requestly really shines. It gives you a JavaScript runtime in pre‑request and post‑response scripts, and an rq object to interact with everything.

One of my favorite use cases is handling authentication automatically. In one of my projects, the API uses a JWT that expires every hour. Instead of manually copying a new token every time, I wrote a pre‑request script that checks if the token has expired, hits the login endpoint, extracts the new token, and updates my environment variables - all before the actual request is sent.

Here's roughly what it looks like (simplified):

// Pre-request script to refresh JWT token if needed
const tokenExpiry = rq.environment.get('token_expiry');
const now = Date.now();

if (!tokenExpiry || now >= tokenExpiry) {
  const loginResponse = await rq.sendRequest({
    url: rq.environment.get('base_url') + '/login',
    method: 'POST',
    body: {
      username: rq.environment.get('username'),
      password: rq.environment.get('password')
    }
  });
  const newToken = loginResponse.data.token;
  rq.environment.set('auth_token', newToken);
  rq.environment.set('token_expiry', now + 3600000); // 1 hour
}

I also use scripting to randomize data during testing. When an endpoint expects a unique email, I generate a random one on the fly with a pre‑request script - no more duplicate entry errors.

Post‑response scripts are great for quick assertions. After a login request, I can write a tiny script that checks if the status is 200 and if a token field exists. I get immediate feedback without leaving the app.

Local Workspace: The feature that I love

The "local workspace" concept is what makes Requestly fundamentally different. Everything - requests, collections, environments is stored in a directory on my computer. I can open that folder and see plain JSON files. I can back them up with any tool I like.

Contrast that with my Postman days. I had dozens of collections, but they were locked inside a cloud workspace. Exporting them was possible, but it required manual steps, and I never really knew what data was being synced. The cloud‑first model also meant I had to be online just to see my saved requests. With Requestly, I can work offline.

Collaboration is also more flexible. When I want to share a collection with an open‑source maintainer, I just push my local workspace files to a Git repository. They clone the repo, open it in Requestly, and start testing - no account creation, no workspace invitations, no data ever touching a third‑party server unless we deliberately choose to use team sync.

Why I Stopped Using Postman

Looking back, my switch came down to three things that really bothered me with Postman, and that Requestly fixed:
Bloated interface: Postman kept adding features I never used. The UI got slower and felt cluttered. Requestly is lean - I can find what I need in seconds.

Cloud‑first by default: I grew uncomfortable with the fact that my API keys, secrets, and environment variables were stored on Postman's servers. Even private workspaces didn't fully ease my mind. Requestly's local‑first approach means my data never leaves my machine unless I explicitly decide to sync it.

Performance: The Postman desktop app became sluggish over time, especially when I had many collections. Requestly feels snappy even with dozens of collections and complex scripts.

Requestly isn't just an alternative; it's a tool that aligns with how I want to work - locally, transparently, and with full control over my data.

Final Thoughts

Requestly started as a Hacktoberfest experiment for me, thanks to a YouTube recommendation from Hitesh Sir. But it quickly became a daily essential. Its local‑first feature, combined with Git‑friendly collections, secure environment management, and powerful scripting, has made API testing and development feel much more enjoyable.

If you're still using a cloud‑based API client and you're tired of the bloat or worried about where your secrets are stored, I'd say give Requestly a try. It might change the way you work, too.

Postman became too expensive for teams. I found a free and better alternative

Mustafa Sayyed — Tue, 24 Mar 2026 20:59:04 +0000

I was working with a friend on a side project, and we had been using Postman for API testing and collaboration for a long time. A few weeks ago, we realized we could no longer collaborate in Postman without paying. We Google it for answers and found shocking news, Postman had quietly changed its pricing and removed team collaboration from the free plan entirely.

When we checked the new pricing (which is effective from March 2026), the Free plan had no team collaboration. Team collaboration now costs $19 per team member per month. That means:

A team of 2 - $38/month ($456/year)
A team of 4 - $76/month ($912/year)

For a small side project that felt too much.

I found a better Open Source alternative: Requestly

After going through a lot of Postman alternatives, I found Requestly a better tool. It is Open Source and has insane features that are actually better than Postman. It is a local-first API Client with Native Git Sync and robust free team collaboration. It also has HTTP Interceptor and API Mocking out of the box.

How we migrated from Postman

Migration becomes the biggest issue when adopting new tools, but not in our case, as Requestly has a one-click Postman importer.

Migration steps:

1. Export your Collections from Postman

Open Postman, find the collection you want to export, and click the three-dot ( … ) menu to export the collection.

After clicking to export, select the recommended Collection v2.1 format and save the file to your local machine.

2. Import the Collections into Requestly

Open Requestly, select API Client, click "import" which is on the left sidebar, then select "Postman Collections and Environments" option.

Then select the file that you want to import.

Start collaborating with your team in Requestly

To collaborate with your team, you need to create a team workspace. In the left sidebar, click "Add" in the team workspace section.

Then give a name to the workspace, and click Create Workspace.

Then you can invite your team and start collaborating.

We've been using Requestly for a few weeks now and haven't looked back. The migration was painless, the collaboration features work flawlessly, and the tool is genuinely more powerful for our workflow than Postman ever was.

Official docs for migrating from Postman to Requestly: https://docs.requestly.com/general/api-client/import-export/import-from-postman#importing-into-requestly

Thanks for Reading.

DEV Community: Mustafa Sayyed