Golden Retriever: Testing REST APIs in VS Code made easy

#vscode #testing #api #rest

As developers, we're always on the hunt for tools that streamline our workflows without forcing us out of our favorite environments. If you're like me—someone who lives in Visual Studio Code and dreads switching apps just to test an API—then I've got something exciting to share. Meet Golden Retriever, a VS Code extension I built to make API testing fast, collaborative, and, dare I say, fun. Think of it as Postman's loyal cousin who stays local, syncs with Git, and doesn't demand a cloud subscription.

In this post, I'll walk you through why I created Golden Retriever, what makes it stand out, and how it can level up your API testing game—all from the comfort of VS Code.

The Problem: API Testing Felt Clunky

A while back, I was working with my team on a project with a bunch of REST APIs. We needed a way to test them locally, share collections, and run Postman-style tests—all without jumping between tools. I'd tried the usual suspects: Postman, Thunder Client, Bruno, you name it. But each had its quirks:

Postman has a VS Code extension, but it doesn't provide a straightforward way to save collections directly in your own Git repo alongside your code. Plus, many features require a subscription.
Thunder Client stayed in VS Code, but it didn't support Postman's test format and had premium features locked behind a paywall.
Bruno was free and Git-friendly, but it lived outside VS Code and used its own collection format.

I wanted something that checked all my boxes: Git-syncable, Postman-compatible, local-first, and—most importantly—inside VS Code. When I couldn't find it, I decided to build it. Enter Golden Retriever.

What Makes Golden Retriever Special?

Golden Retriever is like a trusty dog that fetches exactly what you need. Here's what it brings to the table:

Git-Synced Collections: Store your API collections as JSON files in a /collections folder, version them with Git, and share them with your team. No cloud required.
Postman Compatibility: Import your Postman collections and run Newman-powered tests right in VS Code. If your team already uses Postman, this is a seamless transition.
Performance Testing: Repeat requests with customizable iterations to stress-test your APIs and catch performance hiccups.
Environment Variables: Manage variables via .env files (e.g., BASE_URL=http://localhost:3000) and use them with {{VARIABLE_NAME}} syntax. Toggle between local, staging, and production effortlessly.
Local & Secure: Everything stays on your machine. No data leaves unless you push it to Git. Even your request history clears when you close request tab or VS Code.
REST and GraphQL: Whether you're hitting REST endpoints or querying GraphQL, Golden Retriever has you covered with dedicated editors.

And the best part? It's free and lives right in your VS Code sidebar.

How I Use It (and Why You'll Love It)

Here's a glimpse of how Golden Retriever fits into my workflow:

Team Collaboration: I store collections in my repo, tweak them (e.g., adding a new POST /users request), and push them to Git. My team pulls the updates—no extra steps.
Performance Checks: I'll run a request 50 times to see if my API holds up under load. The stats panel shows me response times and failures instantly.
Pre-Deployment Testing: Before pushing to staging, I test endpoints locally with real data, using variables to swap environments.
Quick Experiments: For one-off tests, I use a .tmp folder (ignored by Git) to mess around without cluttering the shared collections.

Check out this simple example:

# .env
BASE_URL=http://localhost:3009/api
API_KEY=super-secret-key

In Golden Retriever, my request looks like:

Hit "Send," and I see the response right there—no context-switching. The extension uses Postman's schema, so if you're familiar with Postman, you'll feel right at home.

Run Collections: Test Everything at Once

One of my favorite features is the Collection Runner. When you're developing an API, you often need to test multiple endpoints to make sure everything works together properly. With Golden Retriever, you can:

Run an entire collection of requests with a single click
Test with multiple iterations to check for consistency and performance
View detailed statistics for each request
Easily identify slow endpoints or failures

This is incredibly useful when:

You've made changes to your API and want to ensure nothing broke
You're preparing for a release and need to validate all endpoints
You want to stress-test your API under load
You're onboarding a new team member and want to show them how the API works

The Collection Runner supports all the same features as individual requests, including environment variables and tests.

GraphQL Support

Golden Retriever isn't just for REST APIs. It provides first-class support for GraphQL with a dedicated editor experience. Here's how it works:

query GetUser($id: ID!) {
  user(id: $id) {
    name
    email
  }
}

{
  "id": "123e4567-e89b-12d3-a456-426614174000"
}

The GraphQL editor gives you:

A separate variables section for your JSON inputs
The ability to use collection environment variables within both queries and variables

Whether you're working with SpaceX's public GraphQL API or your own custom schema, just set the URL to your graphql, hit send, and you're good to go.

Try It Out Yourself

Ready to give it a spin? Here's how to get started:

Install Golden Retriever from the VS Code Marketplace.
Open VS Code, create a collections folder in your workspace, and start adding requests.
Need a sample project? Clone this Hono-based example to see it in action with a real server.

The extension welcomes you with a clean interface, and if you've used Postman, it'll feel familiar.

Why "Golden Retriever"?

Because it's loyal, dependable, and fetches your API responses with a wagging tail (metaphorically speaking). I've been using it daily, and it's saved me countless hours. Whether you're a solo dev tinkering with APIs or part of a team juggling microservices, I think you'll find it as handy as I do.

Oh, and if you're curious about more tool automation, check out my other extension Corgi that helps manage local development setup of multiple microservices and databases. Its primary use case is to syntax highlight Corgi go cli and to add useful commands to it. There is a sneak peak of it in my YouTube video in the end of golden retriever demo.

So, what do you think? Grab it from the Marketplace, play around, and let me know your thoughts in the comments. Got questions? I'd love to hear them!

Happy testing! 🐾

Photo by Filios Sazeides on Unsplash

Deploy with ease. Manage efficiently. Scale faster.

Leave the infrastructure headaches to us, while you focus on pushing boundaries, realizing your vision, and making a lasting impression on your users.

Get Started