ReqRes is a native macOS web-debugging proxy. It captures the HTTP(S) traffic your Mac sends and receives, lets you inspect every request and response, and lets you change what comes back, without touching your code and, for most apps, without configuring a proxy. Here’s a quick look at how ReqRes helps in everyday work:

• See What Your Apps Actually Send: Capture traffic from apps, browsers and background processes system-wide, with no proxy settings to configure (some command-line tools need an environment variable).
• Debug API Errors: Inspect methods, URLs, status codes, headers and bodies to find exactly where a request goes wrong.
• Mock and Override Responses: Test edge cases and error handling by overriding a response or mapping a URL to a file on disk.
• Pause Requests and Test Auth: Hold a request at a breakpoint, or add and change headers, to see how your app and server react.
• Give Your AI Agent the Network: Let Claude Code, Cursor or any MCP client read real traffic and build mocks, with your approval on every change.

ReqRes is a native SwiftUI app for macOS 14.6 or later, sold as a one-time purchase with a free tier — not a subscription.

1. See Exactly What Your Apps Send and Receive

Most debugging starts with a question the code can’t answer on its own: what actually went over the wire? With 93.4% of developers relying on REST APIs [1], that question comes up every day, and the answer is often different from what the code, the docs or the logs suggest.

No proxy settings to configure

Many debugging setups mean pointing an app, or the whole system, at a proxy and remembering to switch it back afterwards. ReqRes captures traffic system-wide through a macOS Network Extension instead. Requests from your own app, your browsers and background processes land in one list, and when you quit ReqRes there is no system proxy left behind to break your connection. Command-line tools that ignore the system proxy, such as node scripts, Go programs and the Claude Code CLI, are the exception: point them at ReqRes with an environment variable like HTTPS_PROXY, and give node the ReqRes certificate through NODE_EXTRA_CA_CERTS.

Real-time HTTP(S) traffic monitoring

ReqRes shows requests and responses as they happen: the method, URL, status code, headers and body of each one, with a preview for image responses. HTTPS traffic becomes readable once you trust the ReqRes root certificate on your Mac. That gives you full visibility into your API interactions, including calls that never show up in your own logs, such as the ones a third-party SDK makes on your behalf.

Keep the list focused

A busy Mac makes a lot of requests. Host filters scope the list to the hosts you care about and keep them pinned in the sidebar. The search bar takes free text or host:, method:, status: and path: tokens, so a search like host:api.example.com status:500 narrows hundreds of captured sessions down to the one that failed.

2. Debug API Errors

API errors can bring development to a standstill, especially when a request fails in the app but works everywhere else. To tackle them, you need a clear view of what’s happening behind the scenes, and that is what ReqRes gives you: every request and response, captured from the real app, ready to inspect.

Read the whole exchange

Understanding what’s happening "on the wire" is essential for solving network problems. Seeing the full request and response can reveal problems like malformed requests, unexpected status codes or missing headers — issues that may not be apparent from application logs alone. It also helps you validate response codes and payload formats, ensuring the returned data meets expectations [2].

What to check, part by part

When an API call fails, the root cause often lies in the details of the HTTP conversation. ReqRes shows each part of the exchange separately, so you can analyze each element systematically:

Request Headers

• Look for issues with authorization tokens or content types.
• Common problems include missing/expired tokens or incorrect content types.

Request Body

• Check the structure of your data and ensure required fields are included.
• Problems like malformed JSON or missing parameters often originate here.

Response Headers

• Review CORS settings and caching directives.
• Misconfigured CORS or incorrect cache headers can lead to functionality issues.

By breaking down your analysis into these components, you can pinpoint whether the issue stems from client-side formatting, server-side processing, or network configuration. Once you know which part is wrong, the next three use cases let you test the fix before you write it.

3. Mock and Override Responses to Test Edge Cases

Your backend rarely fails on cue, and it may not even exist yet. ReqRes can answer a request on the server’s behalf. That is API mocking, and it lets you keep working when a live API is down, unfinished or unreachable [3].

"API Mocks provide a solution in these scenarios. They return predefined responses for a given API request without executing any underlying business logic. This nature makes Mock API responses fast and reliable, regardless of how often they are accessed."

• Abhishek Sachan, Growth Engineer at Requestly [3]

Override a response

An override rule matches requests to a host and path and answers them with exactly the status code, headers and body you specify; the request never reaches the real server. That makes error paths easy to reach. Turn one endpoint into a 500, return a 403 Forbidden to a login request, or send back a payload with a field missing, then watch how your app copes. Because the rule applies to the real app rather than a test harness, you see the same behaviour your users would, and you can confirm that your application handles unexpected conditions gracefully.

Map a URL to a local file

ReqRes’s Map Local rule links a URL to a file on disk. This is especially useful when backend services are unavailable or incomplete: create local JSON files that mimic the expected API responses and test your application under realistic conditions. Want to see how your app handles an empty list, a very long name or a changed response body? Put that payload in a file and map the URL to it. Your app keeps calling the same URL it always does, so there is no separate mock server to run and nothing in your code to switch.

Keep front-end and back-end work moving

Mocked responses mean front-end and back-end teams can work in parallel without waiting on each other. Front-end developers can build user interfaces against a predefined API contract while back-end developers focus on the implementation, and mocking cuts costs by removing the need for early infrastructure setup [4]. Organizing your mock files to mirror the structure of the live API makes the transition from testing to production much smoother [5].

The usual alternative is a mock server inside your project. For React developers, tools like connect-api-mocker build mock APIs from directories and files, and a create-react-app project then needs a proxy entry like "proxy": "http://localhost:9000/api" in its package.json, or the Express CORS middleware, to reach it without cross-origin errors [6]. That approach works, but it is more code to maintain. Map Local and override rules live in ReqRes, outside your codebase, and you can switch them off when you are done.

4. Pause Requests and Test Authentication

Rules change every matching request, every time. Sometimes you want something more deliberate: to stop one request and decide what happens to it, or to change a header and see what the server says.

Hold a request with a breakpoint

Arm a breakpoint in ReqRes → Settings → Breakpoints, and the next matching request stops before it reaches the server and waits for you. You can send it on as it is, send it on with headers or a body you have changed, or fail it with a status code of your choosing, deciding one request at a time what your app is about to see. (Breakpoints hold HTTPS requests in the current version; plain http:// passes straight through.)

Keep breakpoints narrow — one endpoint and one method. While a request is held, whatever made it is still waiting for a response, and a breakpoint on a whole host will stop every image and analytics ping that host serves.

Add or change headers to test auth

Authentication bugs live in headers: a missing token, an expired one, a header the server expects but never gets. A ReqRes rule can add or change headers on matching requests while the rest of the request and the real response pass through untouched. Swap in an expired token to check your app’s refresh flow, or add a header to see how the server treats it, all without changing your code. If you only need to try something once, a breakpoint lets you edit the headers of that single request before sending it on.

5. Let Your AI Coding Agent Read Real Traffic

Your coding agent already reads your code. ReqRes lets it read the network too. ReqRes includes an MCP server, so Claude Desktop, Claude Code, Cursor or any other MCP client can work with the traffic ReqRes captures instead of asking you to paste headers into a chat window.

What an agent can do

• Read captured requests and responses, including headers and bodies.
• Diff two requests, for example a failing call from your app and one that works, and point at the difference.
• Wait for the request you are about to trigger, so it reports the one you caused rather than everything else captured in the meantime.
• Turn a captured response into a mock, so the endpoint fails (or succeeds) every time while you build around it.
• Export a HAR file of the traffic.

Safe by default

Reads are redacted: credential-shaped values such as Authorization headers, cookies and tokens are removed before anything leaves ReqRes. Changes an agent proposes, like a new rule or mock, wait for your approval before anything happens, and the whole bridge has an off switch. The MCP read tools are included in the free tier.

Conclusion

ReqRes covers the HTTP work that comes up every day: seeing what your apps send, debugging API errors, mocking and overriding responses, pausing requests and testing auth, and giving your AI agent real traffic to work with. Because it works on the real traffic from the real app, you test what your users will actually hit, not a stand-in.

Whether you’re inspecting, mocking, debugging, or mapping local responses, ReqRes contributes to smoother workflows. It removes the hassle of setting up a separate mock server or reconfiguring proxy settings, making it easier to focus on building and refining applications.

ReqRes is a native, sandboxed macOS app with an open-source app shell. It is a one-time purchase rather than a subscription: $60 USD per person, with every 1.x update included. The free version has every feature, with limits of 2 host filters, 1 rule and 10 HTTPS inspections per launch. See the pricing page for details.

FAQs

::: faq

How can ReqRes support developers working offline or without access to a live backend?

ReqRes lets you keep working without an active backend by answering requests itself. A Map Local rule serves a file from disk for a given URL, and an override rule returns the status code, headers and body you specify. Your app keeps calling the same URLs, and ReqRes responds without the request ever reaching the real server.

This is particularly helpful for tasks like quick prototyping, offline testing, or handling situations where the actual API isn’t accessible. By cutting down on the need for external services, ReqRes keeps your development process smooth and efficient, even when connectivity is limited. :::

::: faq

How does ReqRes help with debugging network issues, and what makes it effective for troubleshooting?

ReqRes makes debugging network issues much simpler by capturing HTTP(S) traffic from the apps on your Mac in real time. This instant visibility allows developers to spot and address problems as they happen, saving time and effort.

One standout feature is its ability to override responses and hold requests at a breakpoint. This means you can test error cases and edge cases without needing a server that fails on cue, helping you uncover hidden bugs before your users do. Plus, host filters and the search bar’s host:, method:, status: and path: tokens let you zero in on specific issues, streamlining troubleshooting and boosting development productivity.

By providing detailed insights into requests and responses, ReqRes helps developers pinpoint errors quickly, leading to faster fixes and smoother workflows when dealing with API challenges. :::

::: faq

How does real-time modification of requests and responses with ReqRes enhance API testing and prototyping for developers?

Developers can streamline their testing and debugging processes with ReqRes, which allows real-time modification of requests and responses through rules and breakpoints. By simulating various scenarios without depending on a live backend, they can address integration issues more efficiently. Override and Map Local rules create mock responses that mimic actual API behavior, letting developers test frontend components with realistic data while keeping production environments untouched.

What’s more, the ability to adjust responses on the fly helps developers evaluate how applications respond to different conditions, like errors or unusual data formats. This approach not only boosts application reliability but also shortens development cycles, paving the way for stronger and more dependable software. :::