Redirecting a user back to their previous location is a common requirement in Magento 2 development. Whether you are handling a custom form submission, a login process, or a specific business logic check, ensuring the user returns to their original context is vital for a smooth user experience. In this guide, you will learn the various methods to perform a redirect to the previous page, ranging from legacy implementations to the modern standards required for Magento 2.4 and beyond.

When you need to perform a Magento 2 redirect, you are essentially interacting with the browser's HTTP referer header. Magento provides several built-in tools to handle this gracefully, ensuring that your code remains secure and compatible with the platform's architecture.

Understanding the ResultFactory Approach

The most common way to handle redirects within a controller is by using the ResultFactory. This class is a factory that can create various types of result objects, including redirects, JSON responses, and page layouts.

In older versions of Magento 2 (prior to the deprecation of the Action class), you could easily access the resultFactory property directly from the parent class. Here is how you can implement a redirect back to the referer URL using this method:

namespace Company\Module\Controller\Index;

use Magento\Framework\Controller\ResultFactory; 

class MyAction extends \Magento\Framework\App\Action\Action
{
    public function execute()
    {      
        /** @var \Magento\Framework\Controller\Result\Redirect $resultRedirect */
        $resultRedirect = $this->resultFactory->create(ResultFactory::TYPE_REDIRECT);

        // Your custom logic goes here

        $resultRedirect->setUrl($this->_redirect->getRefererUrl());
        return $resultRedirect;
    }
}

In this example, $this->_redirect->getRefererUrl() fetches the URL the user was on before hitting your controller action. The ResultFactory::TYPE_REDIRECT ensures the response is handled as a 302 redirect.

The Modern Approach: Using Action Interfaces

As Magento has evolved, the base \Magento\Framework\App\Action\Action class has been deprecated in favor of specific Action Interfaces like HttpGetActionInterface or HttpPostActionInterface. This transition promotes better dependency injection practices and cleaner code.

To perform a redirect in a modern Magento 2.4+ environment, you should inject the RedirectInterface and ResultFactory directly into your constructor. This is the recommended approach for forward-compatibility.

namespace Company\Module\Controller\Index;

use Magento\Framework\App\Action\HttpGetActionInterface;
use Magento\Framework\App\Response\RedirectInterface;
use Magento\Framework\Controller\ResultFactory;

class MyAction implements HttpGetActionInterface
{
    public function __construct(
        private readonly ResultFactory $resultFactory,
        private readonly RedirectInterface $redirectResponse
    ) {}

    public function execute()
    {      
        $resultRedirect = $this->resultFactory->create(ResultFactory::TYPE_REDIRECT);

        // Perform your business logic

        $resultRedirect->setUrl($this->redirectResponse->getRefererUrl());
        return $resultRedirect;
    }
}

By using the RedirectInterface, you decouple your controller from the legacy base class while still gaining access to the robust getRefererUrl() method.

Using resultRedirectFactory for Simplicity

If your controller inherits from a class that already provides resultRedirectFactory (common in many core Magento controllers and Adminhtml actions), you can use a more concise syntax. This factory specifically creates redirect objects without needing to pass a type constant.

public function execute()
{
    $resultRedirect = $this->resultRedirectFactory->create();
    $resultRedirect->setRefererUrl();
    return $resultRedirect;
}

Note that setRefererUrl() is a helper method on the redirect object that internally calls the referer logic, making your code even shorter.

Adding Feedback with Message Manager

When redirecting a user, it is a best practice to provide feedback about what just happened. For example, if a user submits a form and is redirected back, they should know if the action was successful or if an error occurred. You can achieve this by using the MessageManager.

public function execute()
{
    $resultRedirect = $this->resultRedirectFactory->create();

    try {
        // Your logic here
        $this->messageManager->addSuccessMessage(__('The operation was successful.'));
    } catch (\Exception $e) {
        $this->messageManager->addErrorMessage($e->getMessage());            
    }

    $resultRedirect->setUrl($this->_redirect->getRefererUrl());
    return $resultRedirect;
}

Redirecting in Admin Controllers

For Adminhtml controllers, the process is very similar, but you often extend \Magento\Backend\App\Action. In the admin area, Magento provides a shorthand method $this->_redirect(...) which can be used for quick redirections.

namespace Vendor\Module\Controller\Adminhtml\Index;

class Fetch extends \Magento\Backend\App\Action
{
    public function execute()
    {
        // Perform admin task
        return $this->_redirect($this->_redirect->getRefererUrl());
    }
}

Frequently Asked Questions

What happens if the Referer URL is missing?

If a user navigates directly to a URL or has browser settings that block referer headers, getRefererUrl() will usually default to the store's base URL. It is always a good idea to provide a fallback URL using $this->_redirect->getRedirectUrl($defaultUrl) if you require a specific destination.

Is resultRedirectFactory better than ResultFactory?

resultRedirectFactory is simply a specialized factory for redirects. While it is more convenient, ResultFactory is more versatile as it can handle all types of responses. In modern interface-based controllers, you will typically inject whichever one fits your specific needs.

Can I use these methods in a Plugin?

Yes, but instead of returning a redirect object directly from an after plugin, you must ensure the plugin's return type matches the observed method's expected return type. Usually, it is cleaner to use a before or around plugin to intercept the response and return a Redirect object.

Wrapping Up

Handling redirects in Magento 2 is a straightforward process once you understand the available factories and interfaces. For legacy projects, the Action class approach works fine, but for modern, scalable Adobe Commerce development, you should prioritize injecting RedirectInterface and ResultFactory into controllers implementing HttpGetActionInterface or HttpPostActionInterface.

By following these patterns, you ensure that your users maintain their browsing context while your application logic remains clean, testable, and aligned with Magento’s architectural standards.