WordPress Memory Exhausted Even After Increasing PHP INI

10 Fixes That Actually Work

If you are seeing the WordPress memory exhausted even after increasing php.ini error, it can be incredibly frustrating. You have already increased the PHP memory limit, yet WordPress still crashes, plugins refuse to load, or you see a fatal memory error.

The important thing to understand is that increasing `memory_limit` is only one part of the solution. WordPress can still run out of available memory because of inefficient plugins, themes, PHP configuration restrictions, large processes, database problems, or a hosting environment that imposes limits elsewhere.

The good news is that this problem is usually fixable.

In this guide, we will explain why the error happens, how WordPress memory limits actually work, and what to check when increasing PHP memory has not solved the problem.

The Core Basics

Before changing anything, it helps to understand the difference between PHP memory, WordPress memory, and the memory available on your hosting account.

PHP uses a setting called `memory_limit` to determine how much memory a single PHP script can consume. You might see values such as:

* `128M`
* `256M`
* `512M`

For example, setting:

“`ini
memory_limit = 256M
“`

allows a PHP process to use up to 256 MB of memory.

WordPress also defines memory requirements through constants such as `WP_MEMORY_LIMIT` and `WP_MAX_MEMORY_LIMIT`. These can be configured in the site’s `wp-config.php` file.

However, increasing these values does not magically create additional physical memory.

Your hosting provider may impose its own limits. PHP-FPM pools, server-level restrictions, CloudLinux limits, container resources, or other hosting controls can prevent WordPress from using the amount of memory you have requested.

There is another important possibility: something on your website is consuming excessive memory.

A badly coded plugin, memory-hungry theme, broken extension, large import, or runaway process can consume hundreds of megabytes. If that happens, simply increasing the limit may temporarily hide the underlying problem rather than fix it.

Step-by-Step Guide to Fix WordPress Memory Exhausted Even After Increasing PHP INI

1. Confirm the Actual PHP Memory Limit

Don’t assume your PHP configuration changed simply because you edited `php.ini`.

Your hosting environment may be using a different PHP configuration file than the one you modified.

In WordPress, go to:

Tools → Site Health → Info → Server

Look for the PHP memory limit value.

If WordPress reports `128M` even though you entered `256M` in `php.ini`, your change has not been applied to the PHP environment running your website.

Depending on your hosting setup, you may need to restart PHP, modify the correct configuration, or contact your host.

2. Increase WordPress Memory in wp-config.php

If the server allows more memory, you can explicitly increase WordPress’s memory allocation.

Open your `wp-config.php` file and locate the line:

“`php
/* That’s all, stop editing! Happy publishing. */
“`

Before that line, add:

“`php
define(‘WP_MEMORY_LIMIT’, ‘256M’);
define(‘WP_MAX_MEMORY_LIMIT’, ‘512M’);
“`

The second value primarily affects administration and backend operations.

Don’t automatically choose enormous values. If a plugin is leaking memory, giving it more memory may simply allow the problem to continue for longer.

3. Check Whether Your PHP INI Setting Is Being Overridden

PHP configuration can exist at multiple levels.

Depending on your server, settings may be controlled by:

* `php.ini`
* `.user.ini`
* `.htaccess`
* PHP-FPM configuration
* Hosting control panel settings
* Server-level configuration

For example, you may change one `php.ini` file while your website is actually running under another PHP version or configuration.

This is particularly common after changing PHP versions.

Always verify the effective PHP memory limit rather than relying on the file you edited.

4. Look for a Plugin Causing Excessive Memory Usage

Plugins are one of the first places to investigate.

A plugin can consume significant memory when performing tasks such as:

* Image processing
* Database searches
* WooCommerce operations
* Backup creation
* Security scanning
* Website migrations
* XML or CSV imports
* Page-builder operations

If the problem started immediately after installing or updating a plugin, that is a strong clue.

Deactivate plugins one at a time and test the website after each change.

If the error disappears, you have a strong candidate for further investigation.

5. Test With a Default WordPress Theme

Themes can also consume substantial memory.

Complex themes may load page builders, custom frameworks, sliders, WooCommerce integrations, animations, and numerous scripts.

Temporarily switch to a default WordPress theme such as a current Twenty Twenty-series theme.

If the memory problem disappears, your theme or one of its integrations may be responsible.

This is a diagnostic step. You can switch back after testing.

6. Check Your Hosting Account’s Resource Limits

This is where many WordPress users get caught.

Your PHP `memory_limit` might say `512M`, but that doesn’t necessarily mean your website has 512 MB of physical server resources available whenever it needs them.

Your hosting plan may have separate restrictions for:

* RAM
* CPU
* PHP workers
* Processes
* Entry processes
* Concurrent connections

If your account repeatedly reaches a resource limit, increasing WordPress’s PHP memory setting won’t solve the underlying problem.

Check your hosting control panel for resource-usage graphs and error reports.

If your site regularly reaches its limits, you may need to optimise the site or move to a hosting plan with more appropriate resources.

7. Increase the PHP Memory Limit Through the Correct Method

Depending on your hosting environment, you may be able to change PHP memory using a control panel.

Some hosts provide a PHP configuration editor where you can select your PHP version and adjust:

“`ini
memory_limit = 256M
“`

If you have SSH access, you can also inspect the active PHP configuration using appropriate server commands.

The key point is simple: change the setting in the environment that actually runs WordPress.

Changing a configuration file that PHP never loads will have no effect.

8. Check for Large or Problematic WordPress Operations

Certain tasks can temporarily require considerably more memory.

Examples include:

* Importing large product catalogs
* Regenerating thousands of thumbnails
* Processing large media libraries
* Running database cleanup tools
* Performing major plugin updates
* Creating backups
* Migrating large websites

If the memory error only appears during one particular operation, don’t necessarily increase memory indefinitely.

Instead, break the operation into smaller batches where possible.

For example, importing 20,000 products in smaller groups may be considerably more manageable than processing everything in one request.

9. Enable WordPress Debugging

If you cannot identify the source, WordPress debugging can provide useful information.

In `wp-config.php`, you can temporarily enable debugging with:

“`php
define(‘WP_DEBUG’, true);
define(‘WP_DEBUG_LOG’, true);
define(‘WP_DEBUG_DISPLAY’, false);
“`

Errors can then be recorded in:

“`text
/wp-content/debug.log
“`

Look for the plugin, theme, file, or function mentioned immediately before the memory exhaustion error.

Important: Don’t leave debugging enabled indefinitely on a production website unless you know exactly what you are doing.

10. Update PHP, WordPress, Themes and Plugins

Outdated software can create compatibility and performance problems.

Make sure you are running supported versions of:

* WordPress
* PHP
* Plugins
* Themes

However, don’t blindly update everything on a live production website without backups.

Create a current backup first, then update carefully.

If the problem appeared after an update, investigate that specific update rather than assuming more memory is required.

Best Practices and Pro Tips

Preventing memory problems is much better than repeatedly increasing PHP limits.

Start by keeping your plugin collection under control. Remove plugins you no longer use instead of simply deactivating them.

Choose reputable plugins that are actively maintained and compatible with your WordPress and PHP versions.

You should also optimise large images, clean unnecessary database data, use caching where appropriate, and keep WordPress updated.

For larger websites, consider monitoring server resources rather than waiting for a fatal error.

A useful rule is this: if a website needs an unusually high PHP memory limit to perform ordinary tasks, investigate why.

A healthy WordPress installation should not continually require more and more memory.

Common Mistakes to Avoid

1. Increasing Memory Forever

Changing `256M` to `512M`, then `768M`, isn’t necessarily a solution. Excessive memory usage often indicates another problem.

2. Editing the Wrong php.ini

Your website may use a different PHP configuration file than the one you edited.

Always verify the effective setting.

3. Ignoring Plugins

A single poorly behaving plugin can consume a huge amount of memory.

Test plugins individually when troubleshooting.

4. Forgetting Hosting Restrictions

The PHP memory limit and your hosting account’s available resources are not always the same thing.

Check both.

Conclusion: Fix the Cause, Not Just the Memory Limit

When you encounter wordpress memory exhausted even after increasing php ini, don’t assume you simply need to keep increasing the number.

First verify the active PHP memory limit. Then check WordPress’s configuration, hosting restrictions, plugins, themes, PHP version, and the specific operation triggering the error.

In many cases, identifying the process or plugin consuming excessive memory is the real solution.

If you need further WordPress troubleshooting help, WP Fix It Co can help you work through configuration, plugin, performance, and common WordPress errors step by step. The goal isn’t simply to make the error disappear—it is to get your WordPress website running reliably again.