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: Finally, Git Works Like It Should
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 Mine
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 Annoying Bits
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 Reason I Stayed
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.
