Requestly for API Developers: A Complete Setup, Testing & Debugging

Learn how Requestly helps your API development workflow for faster debugging, seamless testing, real-time traffic interception, and advanced API mocking. It's a consolidated solution for modern API development; it's very essential for backend developers. where there is a tight schedule of project development.

Requestly for API Developers: A Complete Setup, Testing & Debugging

Previously, when backend and frontend developers worked, at that time a big dependency was the backend being ready for the start of frontend development. Sometimes it takes more time for any changes.

Why Requestly? (Clear, Practical Reasons)

Requestly became popular because it solves frontend + QA + debugging problems that no single other tool solves in one place.

Here’s exactly why people use it:

1. It intercepts & modifies live browser traffic instantly (no proxy setup)
2. It lets you mock any API response directly in the browser
3. It’s built for frontend debugging — all common tasks in one tool
4. Zero backend changes needed
5. Shared rules = consistent debugging across teams
6. Saves huge time during FE/BE integration
7. Perfect for testing code in production (safely)
8. Super easy for non-technical QA

We need practical examples that show how Requestly can be used with your APIs (mocking, testing, rewriting, debugging).

Below are real, ready-to-use .NET Core examples and how Requestly fits into each scenario. for this case we works two steps

Related article

[embed]Requestly: The All-in-One API Tester, Mocking, Traffic Interception & Debugging Tool for Developers Are you a microservice developer working with advanced API mocking, traffic interception, and debugging? Then you must…medium.com

Also, Pre-requisit :

1. Registration Requestly website
2. Download and Install Requestly

Depending on what you want to do:

1. Simple .NET Core Web API Endpoint redirect

You can use Requestly to mock, modify, or override responses of this API during development.

Create a web API project and create a controller

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    [HttpGet("{id}")]
    public IActionResult GetUser(int id)
    {
        var user = new
        {
            Id = id,
            Name = "John Doe",
            Email = "johndoe@example.com",
            Status = "Active"
        };

        return Ok(user);
    }
}

How Requestly Helps

• Mock a different user response without editing code
• Simulate invalid ID, error response, empty data, etc.
• Redirect API from:—in desktop version with free plan “rule” config is not available for this case; you need
• Sign in at Signin https://app.requestly.io/
• Alsoalso add API Client Extension.
• Then open the browser and open the Requestly Cloud.
• Now configure the rule. as a Http Redirrect

Like : [https://prod-api.com/api/users/1](https://neitsbd.com/api/users/1) → [https://localhost:5001/api/users/1](https://localhost:5001/api/users/1)

now Test using a browser.

its automatically redirect to

2: Simulating Error States Using Requestly

Add function by add API code.

[HttpGet("profile")]
public IActionResult GetProfile()
{
    return Ok(new 
    {
        UserName = "developer123",
        Subscription = "Premium"
    });
}

result

Using Requestly

You can modify the API response to test UI error handling:

To check it, we need to create a workspace in the web cloud with proper sign-in and then connect and load the same workspace . our workspace is Test2020

Config rule : Mock Response Example (in Requestly Mock API)

{
    "error": "User profile not found",
    "statusCode": 404
}

and Now Active Network Monitoring with local Desktop Application

Set filter “localhost”

Stop the web aervice and try now

API does not shows unable to found its response

{"error":"User profile not found","statusCode":404}

Now We change our respone by

{"id":1,"name":"Hasan Monsur","email":"hasanmcse@example.com","status":"Active"}

and now check now :

3: Redirect Production API to Local API (Requestly Rule)

Startup code in .NET often uses Prod API

public static class ApiEndpoints
{
    public const string OrderApi = "https://prod.example.com/orders";
}

But during development, you want to call:

https://localhost:5001/orders

Requestly Rule

Redirect Rule:

If URL contains: prod.example.com/orders
→ Replace with: localhost:5001/orders

its example like 1: No code change needed → your frontend now hits your local .NET Core API.

4: Simulate Slow API Response

API in .NET:

[HttpGet("dashboard")]
public IActionResult GetDashboard()
{
    return Ok(new { Message = "Dashboard Loaded" });
}

Requestly Simulation

Using Delay Rule, add:

Delay API response by: 500ms

Now you can test:

• loaders
• skeleton screens
• timeout handling

if we change delay time 1000

response delay time must increase .

5: Inject Debug Headers into .NET Core API

Client sends custom header

Requestly can add a header like:

X-Debug-Mode: true

.NET Core Middleware to read it

public class DebugHeaderMiddleware
{
    private readonly RequestDelegate _next;

    public DebugHeaderMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Headers.TryGetValue("X-Debug-Mode", out var value))
        {
            Console.WriteLine("Debug Mode Enabled from Requestly!");
        }

        await _next(context);
    }
}

public static class DebugHeaderExtension
{
    public static IApplicationBuilder UseDebugHeader(this IApplicationBuilder app)
    {
        return app.UseMiddleware<DebugHeaderMiddleware>();
    }
}

// program.cs

app.UseDebugHeader();

Requestly Action

Use Header Rule:

• Add header: X-Debug-Mode = true

Result: You can enable server logs on demand without code change.

Result:

6: Replace Live API Response with Mock for UI Testing

Live API

[HttpGet("transactions")]
public IActionResult GetTransactions()
{
    return Ok(new[]
    {
        new { Id = 1, Amount = 100, Status = "Success" }
    });
}

Result:

Requestly Mock Response (UI Testing)

[
  {
    "Id": 1,
    "Amount": 100,
    "Status": "Failed"
  },
  {
    "Id": 2,
    "Amount": 500,
    "Status": "Pending"
  }
]

Config:

Result:

For more details, please visit Requestly website

For .NET code download, Requestly-for-dotnet-web-API-developer

Conclusion:

at the end of the article, I inform to you its very easy solution to continue frontend development without dependency of backend development. as a result, a frontend developer can help to backend to get proper time to fix any issues properly.

I offered you others’ Medium articles: Visit My Profile

Also, my GitHub: Md Hasan Monsur

Connect with me at LinkedIn: Md Hasan Monsur