How to Find and Fix WordPress Redirect Issues and Loops

If a URL redirects to the wrong page or your browser shows a “too many redirects” error, something on your website may be causing an unexpected redirect.

The source could be WordPress, a plugin, a theme, or your web server configuration. You can often find out what causes a redirect by opening the affected URL and checking the X-Redirect-By HTTP response header in your browser's developer tools.

If the header identifies WordPress or a plugin, you can use a backtrace snippet to find the function or plugin responsible for the redirect. If the header is missing, inspect your .htaccess file, NGINX configuration, and CDN settings for redirect rules.

What Is a Redirect Loop (ERR_TOO_MANY_REDIRECTS)?

Identifying a redirect loop is usually straightforward, but determining why it occurs can be more difficult. A typical symptom is that the page never fully loads because the browser keeps redirecting the request instead of displaying the site content.

Different browsers may display redirect-loop errors in different ways. They generally report that too many redirects were detected and that the page cannot be loaded.

Chrome, for example, displays the error code ERR_TOO_MANY_REDIRECTS. Firefox may display "The page isn't redirecting properly," while Safari may show "Safari Can't Open the Page".

Common Causes of Unwanted Redirects in WordPress

Cached 301 Redirects

Browsers can cache permanent (301) redirects and continue redirecting a URL even after you remove the original redirect.

To rule out browser caching, test the affected URL in a private window or clear the browser cache before investigating other potential causes.

Mismatched WordPress Address and Site Address

If the site URLs under Settings → General use http:// or a different hostname than the one your server redirects to, WordPress and the server may redirect requests back and forth, causing a redirect loop.

To fix the issue, make both URL fields in WordPress match the address you use on your website. If the fields are locked, check whether WP_HOME or WP_SITEURL is defined in the wp-config.php file.

If you enforce redirects through .htaccess or another server configuration, make sure the destination URL uses the correct protocol (https://) and hostname (www or non-www).

HTTPS Behind a Proxy or CDN

A load balancer or CDN can cause a redirect loop if it sends HTTP requests to WordPress, which then redirects them to HTTPS. If the proxy continues to forward requests over HTTP, the cycle repeats.

On Cloudflare, this often occurs when SSL/TLS encryption is set to Flexible. To resolve the issue, try switching to Full (strict).

If you use a different proxy server, you can add the following code workaround to wp-config.php to ensure WordPress detects the original request as HTTPS:

if ( isset( $_SERVER['HTTP_X_FORWARDED_PROTO'] ) && 'https' === $_SERVER['HTTP_X_FORWARDED_PROTO'] ) {
	$_SERVER['HTTPS'] = 'on';
}

WordPress Core, Plugins and Themes

WordPress can automatically redirect some URLs. For example, if you change a post or page slug, WordPress may redirect visitors from the old URL to the new one instead of showing a 404 error.

To check whether a WordPress canonical redirect is causing the problem, you can temporarily disable it with this line of code:

remove_action( 'template_redirect', 'redirect_canonical' );

Another possible cause is a redirect rule added by a different plugin or theme. Popular examples include Redirection and Rank Math, both of which support custom redirect rules and auto-redirects.

Other plugins and themes may also use redirects for specific purposes. For example, they may redirect visitors after they submit a form or attempt to log in.

If you suspect that a plugin or theme is causing an unexpected redirect, follow the steps below to identify its source.

Server Configuration

Server configuration can be another source of unexpected redirects. If you cannot identify or resolve the issue elsewhere, check your NGINX configuration or the .htaccess file if your site runs on Apache.

On Apache, you can usually find .htaccess in the main directory where your WordPress files are stored. If you have configured redirects directly in NGINX, check the server configuration for rules that may conflict with other URLs or rewrite rules.

Server configuration files can contain hundreds of lines, so reviewing them manually may take some time. AI can help you scan the configuration for potentially invalid, duplicate, or conflicting redirect rules.

How to Find What Is Causing the Redirect

Step 1: Follow the Redirect Chain

When a visitor opens a page on your WordPress site, their browser first sends a request to the server. The server then returns a response containing HTTP headers.

These headers can reveal the redirect status and may contain an X-Redirect-By header added by WordPress or a plugin. You can inspect the response directly using your browser's developer tools. Online tools such as HTTP Status Code Checker or Redirect Checker can be useful as well.

Here is how to inspect the HTTP headers using your browser:

Chrome

1. Open DevTools with F12 (or Cmd+Option+I on Mac).
2. Click the Network tab.
3. Reload the page, then click the relevant request in the list.
4. Look at the Headers inside the right sidebar.

Firefox

1. Open DevTools with F12 (or Cmd+Option+I on Mac).
2. Go to the Network tab.
3. Reload the page, then click the relevant request in the list.
4. The Headers section should appear in the right sidebar.

Step 2: Check the X-Redirect-By Header

When you are trying to track down a redirect issue, check for the X-Redirect-By HTTP header. WordPress adds this header when a redirect is performed using the wp_redirect() function.

If the header is missing, the redirect may be occurring at the server level, such as in .htaccess or nginx.conf, before PHP or WordPress code is executed. However, the absence of this header does not by itself prove that the redirect originates from the server, as a plugin or custom code can also perform redirects without adding the header.

The X-Redirect-By header can indicate that a redirect was generated by WordPress, a plugin, or a theme. By default, WordPress uses WordPress as the header value. Some plugins, such as Yoast SEO or Permalink Manager, may replace the default value with their own name.

For example, a response might include:

HTTP/1.1 301 Moved Permanently
Location: https://example.com/new-page/
X-Redirect-By: WordPress

Step 3: Trace the Redirect With a PHP Backtrace

The X-Redirect-By response header indicates that WordPress issued a redirect, but it does not identify the component that initiated it. To trace the redirect's origin, you can intercept the redirect and output a PHP backtrace showing the call stack that led to wp_redirect().

The snippet below works with redirects triggered by wp_redirect() and wp_safe_redirect(). It can help you find out whether the redirect comes from WordPress core, a plugin, or your theme.

It does not detect redirects configured in .htaccess, NGINX, or a CDN. If the browser still redirects but no debug page appears, the redirect likely occurs outside WordPress.

/**
 * Redirect debugger for administrators.
 *
 * Pauses front-end redirects made with wp_redirect() or wp_safe_redirect()
 * and shows which function, plugin or theme triggered them.
 * Remove this snippet when you have finished troubleshooting.
 */
add_filter( 'wp_redirect', 'bis_debug_wp_redirect', 10, 2 );

function bis_debug_wp_redirect( $location, $status = 302 ) {
	// Leave the admin area, AJAX, cron and REST/JSON requests alone.
	if ( is_admin() || wp_doing_cron() || wp_is_json_request() || ( defined( 'REST_REQUEST' ) && REST_REQUEST ) ) {
		return $location;
	}

	// Only debug redirects for logged-in administrators.
	if ( ! current_user_can( 'manage_options' ) ) {
		return $location;
	}

	// Stop Query Monitor from adding its output to the debug page.
	do_action( 'qm/cease' );

	$url = esc_url( $location );

	$html = sprintf(
		'<div class="bis">
		<h2>%1$s <span id="bis-countdown">20</span> %2$s</h2>
		<h3 id="bis-redirect-link" data-url="%3$s">%4$s (HTTP %9$d):</h3>
		<pre><code>%3$s</code></pre>
		<p>
		<a href="%3$s" class="button">%5$s</a>
		<a href="#" onclick="bisStopRedirect(); return false;" class="button">%6$s</a>
		</p>
		%7$s
		<p class="bis-text-muted bis-text-center">%8$s</p>
		</div>',
		esc_html__( 'Redirecting in', 'bis' ),
		esc_html__( 'seconds...', 'bis' ),
		$url,
		esc_html__( 'Target URL', 'bis' ),
		esc_html__( 'Redirect now', 'bis' ),
		esc_html__( 'Stop redirect', 'bis' ),
		bis_get_redirect_backtrace(),
		esc_html__( 'Disable redirect debugging when troubleshooting is complete.', 'bis' ),
		(int) $status
	);

	$html .= <<<'HTML'
	<style>
	.bis .backtrace-table{width:100%;border-collapse:collapse;margin-top:10px;font-size:90%}
	.bis .backtrace-table th,.bis .backtrace-table td{border:1px solid #ddd;padding:8px;text-align:left}
	.bis .backtrace-table th{background:#f2f2f2}
	.bis .bis-text-muted{color:#808080}
	.bis .bis-text-center{text-align:center}
	</style>
	<script>
	let bisCountdownInterval;

	function bisCustomRedirect(count) {
	const countdown = document.getElementById('bis-countdown');
	if (!countdown) return;

	countdown.textContent = count;

	if (count > 0) {
	bisCountdownInterval = setTimeout(() => bisCustomRedirect(count - 1), 1000);
	} else {
	const link = document.getElementById('bis-redirect-link');
	if (link) window.location.href = link.dataset.url;
	}
	}

	function bisStopRedirect() {
	clearTimeout(bisCountdownInterval);
	}

	bisCustomRedirect(20);
	</script>
	HTML;

	// phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
	wp_die( $html, esc_html__( 'Redirecting...', 'bis' ), array( 'response' => $status ) );
}

function bis_get_redirect_backtrace() {
	// Skip this function and bis_debug_wp_redirect().
	// phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_debug_backtrace
	$trace = array_slice( debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS ), 2 );

	if ( ! $trace ) {
		return '';
	}

	if ( ! function_exists( 'get_plugins' ) ) {
		require_once ABSPATH . 'wp-admin/includes/plugin.php';
	}

	$abspath = wp_normalize_path( ABSPATH );
	$plugin_dir = trailingslashit( wp_normalize_path( WP_PLUGIN_DIR ) );
	$mu_dir = trailingslashit( wp_normalize_path( WPMU_PLUGIN_DIR ) );
	$theme_root = trailingslashit( wp_normalize_path( get_theme_root() ) );
	$content_dir = trailingslashit( wp_normalize_path( WP_CONTENT_DIR ) );
	$plugins = get_plugins();
	$rows = '';

	foreach ( $trace as $item ) {
		// Calls made internally by PHP have no file to show.
		if ( empty( $item['file'] ) ) {
			continue;
		}

		$file = wp_normalize_path( $item['file'] );
		$function = ( isset( $item['class'] ) ? $item['class'] . $item['type'] : '' ) . $item['function'];

		if ( 0 === strpos( $file, $plugin_dir ) ) {
			$slug = strtok( substr( $file, strlen( $plugin_dir ) ), '/' );
			$name = $slug;

			foreach ( $plugins as $plugin_file => $data ) {
				if ( $plugin_file === $slug || 0 === strpos( $plugin_file, $slug . '/' ) ) {
					$name = $data['Name'];
					break;
				}
			}

			$source = '<strong>Plugin</strong><br>' . esc_html( $name );
		} elseif ( 0 === strpos( $file, $mu_dir ) ) {
			$source = '<strong>Must-use plugin</strong><br>' . esc_html( strtok( substr( $file, strlen( $mu_dir ) ), '/' ) );
		} elseif ( 0 === strpos( $file, $theme_root ) ) {
			$slug = strtok( substr( $file, strlen( $theme_root ) ), '/' );
			$theme = wp_get_theme( $slug );
			$source = '<strong>Theme</strong><br>' . esc_html( $theme->exists() ? $theme->get( 'Name' ) : $slug );
		} elseif ( 0 === strpos( $file, $content_dir ) ) {
			// Drop-ins such as advanced-cache.php or object-cache.php.
			$source = '<strong>wp-content</strong><br>' . esc_html( basename( $file ) );
		} elseif ( 0 === strpos( $file, $abspath ) ) {
			$source = '<strong>WordPress Core</strong>';
		} else {
			$source = '<strong>Other</strong>';
		}

		$rows .= sprintf(
			'<tr><td><code>%s</code></td><td>%s</td><td>%s:%d</td></tr>',
			esc_html( $function ),
			$source,
			esc_html( str_replace( $abspath, '', $file ) ),
			(int) ( $item['line'] ?? 0 )
		);
	}

	return sprintf(
		'<table class="backtrace-table">
		<thead><tr><th>%s</th><th>%s</th><th>%s</th></tr></thead>
		<tbody>%s</tbody>
		</table>',
		esc_html__( 'Function', 'bis' ),
		esc_html__( 'Source', 'bis' ),
		esc_html__( 'Called from', 'bis' ),
		$rows
	);
}

When you are logged in as an administrator, any front-end URL that would trigger a redirect displays a debug page instead. This does not affect logged-out visitors or redirects in the WordPress admin dashboard.

The debug page shows the destination URL, HTTP status code, and function calls involved in the redirect, along with the plugin or theme each call belongs to.

Step 4: Disable Plugins One by One

Redirect loops can happen when two WordPress plugins interfere with each other. One plugin might redirect visitors to a URL, while another sends them back to the original URL.

To identify the plugin causing the conflict, you can also deactivate your plugins one at a time and test the affected URL after each change. This process can take time if your site uses many plugins, so other troubleshooting methods may be more practical.

Frequently Asked Questions

add_filter( 'x_redirect_by', '__return_false' );