What Should My PHP Memory Limit Be?

Choosing the right memory_limit for PHP is a balancing act. Set it too low and your scripts may crash with “Allowed memory size exhausted” errors. Set it too high and you risk exhausting server resources, slowing down other applications, or even crashing the entire server. This guide walks you through the factors that influence the ideal memory limit, provides practical recommendations, and shows you how to adjust the setting safely.

Understanding the `memory_limit` Directive

The memory_limit directive in php.ini defines the maximum amount of memory a single PHP script can allocate. It is measured in bytes, but you can use shorthand notations such as 128M (megabytes) or 1G (gigabytes).

Default Values Across Environments

PHP 8.x (default builds): 128 MB
Shared hosting providers: Often 64 MB to 256 MB, sometimes locked down.
Dedicated or VPS servers: Administrators may raise it to 512 MB, 1 GB, or more depending on the workload.

How PHP Measures Memory

PHP counts the memory allocated by the script itself, including extensions, internal data structures, and any objects you create. It does not count the memory used by the web server (e.g., Apache or Nginx) or the operating system.

Key Factors That Influence the Ideal Limit

1. Application Type

Different kinds of applications have varying memory footprints:

Simple sites or blogs: 64 MB–128 MB is usually sufficient.
E‑commerce platforms (Magento, WooCommerce): 256 MB–512 MB is common.
Framework‑heavy apps (Laravel, Symfony, Yii): 256 MB–1 GB, especially during heavy data processing or when using queues.
Image/video processing, PDF generation, or data import scripts: 512 MB–2 GB, depending on file size.

2. Server Resources

Never set a limit that exceeds the physical RAM available to the web server. A good rule of thumb is to keep the total memory_limit across all concurrent PHP workers below 70% of total RAM to leave headroom for the OS and other services.

3. Concurrency & Process Manager

If you use php-fpm or mod_php, each child process inherits the memory_limit. Multiply the limit by the number of children to estimate total PHP memory usage. Example:

# php-fpm pool configuration
pm.max_children = 20
memory_limit = 256M
# Approximate total PHP memory: 20 × 256M = 5.12GB

4. Third‑Party Libraries

Some libraries (e.g., PHPExcel, Imagick, Guzzle) allocate large buffers. Review their documentation for recommended memory settings.

Practical Steps to Determine the Right Limit

Step 1: Benchmark Your Current Setup

Use memory_get_peak_usage() or memory_get_usage() inside your scripts to log peak memory consumption. Example:

<?php
// At the end of a request
error_log('Peak memory: ' . memory_get_peak_usage(true) . ' bytes');
?>

Step 2: Add a Safety Buffer

Once you know the typical peak usage, add a 20‑30% buffer to accommodate occasional spikes.

Step 3: Adjust `php.ini` or Pool Config

For a global change, edit php.ini:

memory_limit = 256M

For per‑pool settings in php-fpm:

[www]
php_value[memory_limit] = 256M

Step 4: Restart the Service

After changes, restart the PHP handler:

# For php-fpm
systemctl restart php8.2-fpm

# For Apache with mod_php
systemctl restart httpd

Common Pitfalls & How to Avoid Them

Setting “-1” (unlimited): This removes any safeguard and can quickly consume all server RAM during a runaway script.
Over‑allocating on shared hosting: Many hosts enforce a hard ceiling; exceeding it will trigger a fatal error regardless of your php.ini setting.
Forgetting to update CLI configuration: The command‑line PHP may use a separate php.ini. Run php -i | grep memory_limit to verify.
Ignoring memory‑intensive cron jobs: Scheduled scripts often run without a web request timeout, so allocate more memory if they process large datasets.

When to Use a Higher Limit (≥ 1 GB)

Consider raising the limit only when you have a clear, measured need, such as:

Batch image manipulation (e.g., generating thumbnails for thousands of photos).
Large CSV or XML imports exceeding 100 MB.
Complex data analytics performed in‑process rather than off‑loaded to a queue.

In these scenarios, also evaluate whether moving the heavy work to a background worker (e.g., queue or cron) would be more efficient.

Final Recommendation Checklist

Measure current peak memory usage with memory_get_peak_usage().
Add a 20‑30% safety margin.
Ensure total PHP memory across all workers stays below 70% of server RAM.
Set the limit in the appropriate php.ini or pool file.
Restart the PHP service and monitor logs for “Allowed memory size exhausted” errors.

By following these steps, you’ll strike a balance between stability and performance, keeping your PHP applications running smoothly without hogging server resources.

FAQs

What does `memory_limit = -1` mean?

It disables the memory limit, allowing scripts to consume unlimited RAM. Use only in controlled, isolated environments.

Can I set a different memory limit per virtual host?

Yes. Use .htaccess (Apache) or php_admin_value[memory_limit] in your php-fpm pool configuration to override the global setting for a specific site.

Does increasing `memory_limit` improve performance?

Only if your scripts were previously hitting the limit and crashing. Otherwise, a higher limit merely provides more headroom; it does not speed up code execution.

How do I check the current memory limit from the command line?

Run php -r "echo ini_get('memory_limit');". This shows the value for the CLI interpreter.