302 HTTP Status Code in ASP.NET Core Web API

Back to: ASP.NET Core Web API Tutorials

302 HTTP Status Code in ASP.NET Core Web API

In this article, I will discuss How to Return 302 “Found” or “Temporary Redirect” HTTP Status Code from the ASP.NET Core Web API Controller Action method with Examples. Please read our previous article discussing How to Return 301 HTTP Status Code in ASP.NET Core Web API with Examples.

What is 302 HTTP Status Code?

The 302 HTTP Status Code, also known as “Found” or “Moved Temporarily,” is used for redirection. When a web server responds with this status code, it tells the client (for example, a web browser) that the requested resource has been temporarily moved to a different URI (Uniform Resource Identifier). Unlike the HTTP 301 status code, which indicates a permanent redirect, a 302 status code suggests that the redirect is only temporary. The original URL is expected to be used again in the near future.

When a server returns this status code, it also provides the new URL in the Location header of the response. This is typically used when a webpage or resource has been moved, and the server wants to redirect the client to this new location without the client needing to make a new request.

How HTTP 302 Status Code Works?

• Client Request: The client requests a resource from the server using a specific URI.
• Server Response with 302: The server responds with a 302 Status Code, indicating that the requested resource has temporarily moved to a different URI. The server includes this new URI in the response’s Location header.
• Client Follows Redirect: The client then makes a new request to the URI provided in the Location header.
• Server Responds to New Request: If the resource is successfully retrieved, the server responds to this new request with a 200 OK status code.

How Do We Implement a 302 Redirect in ASP.NET Core Web API?

Implementing a 302 redirect in an ASP.NET Core Web API is straightforward. We typically handle redirects in a Web API when we want to direct the client to a different endpoint or resource temporarily. We can implement this in 3 ways in ASP.NET Core Web API. They are as follows:

• Using Redirect Method.
• Manually Creating a RedirectResult with a 302 Status Code.
• Setting Status Code and Location Header Manually.

Redirect Method in ASP.NET Core Web API

The simplest way to perform a 302 redirect in an ASP.NET Core controller is by using the Redirect method provided by the ControllerBase class, which returns a RedirectResult. This method is useful when you want to redirect the request to another URL temporarily. For a better understanding, please modify the Employee Controller as follows:

using Microsoft.AspNetCore.Mvc;
namespace ReturnTypeAndStatusCodes.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmployeeController : ControllerBase
    {
        [HttpGet]
        [Route("OldEndpoint")]
        public IActionResult GetFromOldEndpoint()
        {
            // The URL of the new location for the resource
            //string newUrl = "https://localhost:7128//api/Employee/NewEndpoint";

            //return Redirect("/api/Employee/NewEndpoint");

            string? newUrl = Url.Action("GetFromNewEndpoint", "Employee");

            if (newUrl == null)
            {
                // Handle the error or generate a default URI
                return BadRequest("Unable to generate location URI for the new resource.");
            }

            // Temporary redirect to the new endpoint
            return Redirect(newUrl);
        }

        [HttpGet]
        [Route("NewEndpoint")]
        public IActionResult GetFromNewEndpoint()
        {
            // Handle the request as usual
            return Ok("This is the new endpoint.");
        }
    }
}

In this example, when a client makes a GET request to /api/Employee/OldEndpoint, the GetFromOldEndpoint method responds with a 302 Status Code and a Location header indicating the URI of the new endpoint (/api/Employee/NewEndpoint). The client is then expected to make a new request to the URI specified in the Location header.

Now, if you make a request to the /API/Employee/OldEndpoint, then the client will get a 302 Temporary Redirect response, and then immediately, it will call the new URL. So, to understand this better, open the Fiddler tool and make a Get Request to the /api/Employee/OldEndpoint URL as shown in the below image:

Once you click on the Execute button, you will see: First, it will execute the /api/Employee/OldEndpoint URL and will get the 302 response, and then immediately it will execute the /api/Employee/NewEndpoint from where it will get the actual response as shown in the below image:

Now, if you open the /api/Employee/OldEndpoint URL by double-clicking on it, then you will see the following in the Response header, as shown in the image below.

Now, if you open the /api/Employee/NewEndpoint URL by double-clicking on it, then you will see the actual data in the Response body, as shown in the image below.

Note: If you are getting a 302 Status Code, then as a client, you do not need to replace the Old URL with the new URL.

Manually Creating a RedirectResult with a 302 Status Code:

If you need more control over the response, you can manually create a RedirectResult object and specify the status code explicitly, i.e., you need to set the permanent parameter values to false. For a better understanding, please modify the Employee Controller as follows:

using Microsoft.AspNetCore.Mvc;
namespace ReturnTypeAndStatusCodes.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmployeeController : ControllerBase
    {
        [HttpGet]
        [Route("OldEndpoint")]
        public IActionResult GetFromOldEndpoint()
        {
            // The URL of the new location for the resource
            //string newUrl = "https://localhost:7128//api/Employee/NewEndpoint";

            string? newUrl = Url.Action("GetFromNewEndpoint", "Employee");

            if (newUrl == null)
            {
                // Handle the error or generate a default URI
                return BadRequest("Unable to generate location URI for the new resource.");
            }

            // Temporary redirect to the new endpoint
            return new RedirectResult(newUrl, permanent: false);
        }

        [HttpGet]
        [Route("NewEndpoint")]
        public IActionResult GetFromNewEndpoint()
        {
            // Handle the request as usual
            return Ok("This is the new endpoint.");
        }
    }
}

Setting Status Code and Location Header Manually:

For even more control, you can construct the response manually by setting the StatusCode to 302 and the Location header to the temporary redirect URL. For a better understanding, please modify the Employee Controller as follows:

using Microsoft.AspNetCore.Mvc;
namespace ReturnTypeAndStatusCodes.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmployeeController : ControllerBase
    {
        [HttpGet]
        [Route("OldEndpoint")]
        public IActionResult GetFromOldEndpoint()
        {
            // The URL of the new location for the resource
            //string newUrl = "https://localhost:7128//api/Employee/NewEndpoint";

            string? newUrl = Url.Action("GetFromNewEndpoint", "Employee");

            if (newUrl == null)
            {
                // Handle the error or generate a default URI
                return BadRequest("Unable to generate location URI for the new resource.");
            }

            // Redirects Temporarily to the new URL with a 302 HTTP status code
            Response.StatusCode = 302; // HTTP 302 Redirect Temporarily
            Response.Headers.Location = newUrl;
            return new EmptyResult();
        }

        [HttpGet]
        [Route("NewEndpoint")]
        public IActionResult GetFromNewEndpoint()
        {
            // Handle the request as usual
            return Ok("This is the new endpoint.");
        }
    }
}

When Should We Use 302 HTTP Status Code in ASP.NET Core Web API?

The following are several scenarios where using a 302 HTTP status code is appropriate:

• Temporary Relocation of Resources: If a resource is temporarily moved to another location and you intend to move it back to the original location in the future, a 302 redirect is appropriate. For example, during temporary maintenance or testing.
• A/B Testing: When you want to test different versions of a resource (e.g., a web page or an API endpoint) to analyze performance or user interaction, you can use 302 redirects to direct users to different versions randomly.
• Geolocation-based Redirection: Redirect users to different resources based on their geographic location. For instance, users from different countries might be redirected to region-specific servers or endpoints.
• User Authentication and Authorization: After a successful login, you might temporarily redirect users to a specific dashboard or resource based on their role or profile.
• Temporary Changes in API Structure: If you are in the process of restructuring your API and temporarily moving endpoints, a 302 redirect can help manage the transition without breaking client applications.

To understand the above use cases, please look at the following Test Controller. This is not the actual Implementation, but you will get some idea about the above use case in ASP.NET Core Web API:

using Microsoft.AspNetCore.Mvc;
using System.Net;
namespace ReturnTypeAndStatusCodes.Controllers
{
    [Route("api")]
    [ApiController]
    public class TestController : ControllerBase
    {
        //Temporary Maintenance
        [HttpGet("old-endpoint")]
        public IActionResult RedirectToMaintenancePage()
        {
            // Specify the maintenance page URL
            string maintenanceUrl = "https://www.example.com/maintenance";
            return Redirect(maintenanceUrl);
        }

        //A/B Testing
        [HttpGet("test-endpoint")]
        public IActionResult RedirectToTestVersion()
        {
            // Randomly redirect to version A or version B
            string testUrl = (new Random().Next(2) == 0)
                ? "https://www.example.com/versionA"
                : "https://www.example.com/versionB";

            return Redirect(testUrl);
        }

        //Geolocation-based Redirection
        [HttpGet("geo-endpoint")]
        public IActionResult RedirectToRegion()
        {
            string userIp = HttpContext.Connection.RemoteIpAddress?.ToString();
            string redirectUrl;

            // This is a simplified example, real implementation would need a geo-IP service.
            if (userIp != null && IPAddress.TryParse(userIp, out IPAddress ipAddress))
            {
                // Assume IP addresses starting with "192." are from Region A for demonstration
                redirectUrl = ipAddress.ToString().StartsWith("192.")
                    ? "https://www.example.com/regionA"
                    : "https://www.example.com/regionB";
            }
            else
            {
                // Default redirect if IP is not valid or not detectable
                redirectUrl = "https://www.example.com/default";
            }

            return Redirect(redirectUrl);
        }
    }
}

In the next article, I will discuss how to Return 304 HTTP Status Code in ASP.NET Core Web API with Examples. In this article, I try to explain how to Return 302 Temporary Redirect or Found HTTP Status Code in ASP.NET Core Web API with Examples. I hope you enjoy this article on “302 Temporary Redirect or Found HTTP Status Code in the ASP.NET Core Web API.”