Hosting · Explainer
What Are PHP Workers in WordPress Hosting?
Short answer
A PHP worker is a server process that runs one uncached WordPress request at a time. It loads WordPress, runs your theme and plugin code, queries the database, and builds the page. Your worker count sets how many such requests can run at the same moment, so it limits concurrency, not total visits.
Key takeaways
- A PHP worker handles one uncached WordPress request at a time, then becomes free for the next request.
- Cached pages skip PHP workers, so a high cache hit rate stretches a small worker pool much further.
- WordPress.org recommends PHP 8.3 or greater as of November 2026, with PHP 7.4 kept only as a legacy floor.
- Kinsta lists 2 to 4 PHP threads at 256MB each on entry-level plans, rising to 10 to 16 threads on upper tiers.
- When all workers are busy, requests queue and can end in 502 or 504 errors if the queue fills.
- More workers do not fix slow code, so shorten slow queries and outside calls before you pay for more workers.
What is a PHP worker in WordPress hosting?
A PHP worker is a server process that runs one uncached WordPress request at a time.
WordPress is written in PHP, so a page that is not already cached needs PHP code to run before a visitor sees anything. The worker is the process that does that job. Kinsta calls the same thing a PHP thread and says each thread handles one request at a time.
Hosts use different names for the same limit. Kinsta says PHP threads, WP Engine says PHP workers, and other hosts may say PHP processes or concurrent PHP requests. On most modern servers the work is done by PHP-FPM, the FastCGI Process Manager.
How does a PHP worker handle a request?
A worker picks up one request, runs the PHP code, waits for the database, builds the HTML, and then becomes free again.
The flow is simple. A visitor asks for a page, the web server passes the request to PHP-FPM, and PHP-FPM hands it to a free worker. That worker loads WordPress, runs the active theme and plugins, and queries the database.
When the page is built, the worker sends the HTML back and waits for the next request. A slow database query holds the worker for the whole wait, so one slow page can block other visitors. Kinsta gives an example where a 10-second query locks one thread for that entire time.
What requests use a PHP worker and what requests do not?
Uncached requests use a worker, while pages served from full-page cache do not use one at all.
Cached pages are the easy case. If a page is already stored in cache, the server sends that stored copy and PHP never runs. That is why cache matters so much for this limit.
These requests normally need a worker:
- Logged-in page views, because logged-in users usually bypass page cache
- WooCommerce cart, account, and checkout pages
- Form submissions and site search
- Admin pages and admin-ajax requests
- REST API requests that are not cached
WP Engine states that each uncached page request is handled by a PHP worker, and that many requests served from its cache are not handled by a worker. Static files such as images and CSS also skip PHP when they are served directly.
How many PHP workers do you need?
You need enough workers to cover your uncached requests per second times the average time each request takes.
Kinsta gives this rough formula: required threads are about equal to uncached requests per second times average execution time. Its example is a site with 10 uncached requests per second and an average time of 0.5 seconds, which needs about 5 threads.
The same page shows the other side of the math. If a request takes 250 milliseconds, each thread can process 4 requests per second, so 8 threads give a theoretical maximum of 32 requests per second. That figure assumes every request takes exactly 250 milliseconds, so treat it as a guide, not a promise.
Use these starting points when you compare plans:
- A small blog with mostly cached traffic: 2 to 4 workers
- A busy blog or a small store: 4 to 6 workers
- A WooCommerce store: 6 to 12 workers, depending on checkout volume and filters
- A membership site or course site: similar to a store, because logged-in users bypass cache
Ask your host for the exact number on your plan before a sale or a launch. If you are choosing WordPress hosting, put worker count next to price, visits, storage, and support in your comparison.
How many PHP workers do hosts give you?
The number varies by host and plan, and some hosts publish it while others do not.
Kinsta publishes its figures, which makes it a useful example as of November 2026. Its blog lists entry-level plans at 2 to 4 threads at 256MB per thread, and mid-tier plans at 6 to 8 threads at 256MB.
Upper-tier plans run 10 to 16 threads at 512MB per thread, while multisite plans sit at 8 to 14 threads.
| Kinsta tier | PHP threads | Memory per thread |
|---|---|---|
| Entry-level | 2 to 4 | 256MB |
| Mid-tier | 6 to 8 | 256MB |
| Upper-tier | 10 to 16 | 512MB |
| Multisite | 8 to 14 | Varies by tier |
Kinsta also sells a PHP performance add-on at $10 per additional 500MB of memory pool per month, as of November 2026. Its docs give an example where 4 threads sharing a 2GB pool get 512MB each.
The maximum memory limit per thread is 1024MB, so adding threads without adding memory cuts the memory each thread gets.
WP Engine does not publish a worker count on its plan pages. Its support docs explain the queue instead, and say that when a site cannot be optimised further and all requests are real, it is most likely time to upgrade to a larger server with more PHP workers.
What happens when you run out of PHP workers?
New requests wait in a queue, and if the queue fills they fail with 502 or 504 errors.
Kinsta describes the pattern in this order: requests queue inside Nginx and PHP-FPM, visitors see slow pages and spinning loaders, and 502 or 504 errors appear once queue capacity fills. Recovery typically happens within 30 to 120 seconds after slow work finishes and the cache warms.
WP Engine adds a detail about priority. Its docs say real human traffic sits in the highest priority queue, while AJAX, XMLRPC, and well-known bot requests sit in a low priority queue.
A 504 can occur when too many items sit in the backlog and items are evicted. A 502 can occur when items take too long and are killed to free a worker.
The same WP Engine page names plugins that tend to overwhelm workers: view and share counter plugins, plugins that generate popups, and ad plugins that hit admin-ajax. Those plugins create large amounts of uncached traffic, which hurts most when traffic is already high.
How do you check PHP workers on your site?
You cannot see your worker count in WordPress itself, so ask your host and check your PHP version in Site Health.
Start in the dashboard. Go to Tools, then Site Health, then the Info tab, then expand Server and read the PHP version row. That tells you which PHP version runs your site, not how many workers you have.
WordPress.org recommends PHP 8.3 or greater as of November 2026, with MariaDB 10.11 or greater or MySQL 8.4 or greater. WordPress still runs on PHP 7.4 and later, but WordPress.org says those older versions have reached official End Of Life and may expose a site to security risks.
PHP support dates matter here too. The PHP project lists security support until 31 December 2026 for PHP 8.2, 31 December 2027 for PHP 8.3, 31 December 2028 for PHP 8.4, and 31 December 2029 for PHP 8.5, as of November 2026.
A site on PHP 8.2 should plan a move before that first date passes.
For the worker number itself, ask support in writing: how many PHP workers or threads does my plan include, is the number per site, and can I change it? If you run your own server, check the PHP-FPM pool file for the setting below.
What controls the worker count on your own server?
On your own server, the PHP-FPM setting pm.max_children sets the worker limit.
The PHP manual says pm.max_children sets the limit on the number of simultaneous requests that will be served. It is mandatory in the pool settings, and it applies in all three process manager modes.
Those modes are static, dynamic, and ondemand. Static keeps a fixed number of workers, dynamic grows and shrinks between spare-server limits up to the maximum, and ondemand starts workers only when requests arrive and kills idle ones after a timeout.
Other PHP-FPM defaults shape the same pool:
- pm.max_requests defaults to 0, which means a worker never restarts after a set number of requests
- pm.process_idle_timeout defaults to 10 seconds for ondemand pools
- listen.backlog defaults to 511 on Linux, which sets how many waiting connections the socket queue holds
A safe worker count comes from memory, not from a round number. Divide the RAM you can give PHP by the average memory one worker uses, then leave room for the database, the web server, and the operating system.
Raising the count past what RAM allows can push the server into swapping or out-of-memory errors.
How can you use fewer PHP workers?
Cache more pages, shorten slow requests, and move heavy work away from live page loads.
Caching is the largest lever. A site where 80 percent of requests hit edge cache needs workers for only the remaining 20 percent, according to Kinsta. That is why a small worker pool can still serve a busy blog if most visitors read the same cached pages.
Try these steps in order:
- Turn on full-page caching and check that logged-out pages show a cache hit
- Fix slow database queries and remove plugins that add slow queries to every page
- Cache outside API calls, or move them to background jobs where possible
- Reduce admin-ajax calls from counters, popups, and live widgets
- Schedule cron jobs and imports for quiet hours
If you want a broader speed plan, read our guide on how to speed up WordPress.
For the other limits on a plan, see how to read a hosting plan's CPU and RAM limits.
What is the difference between PHP workers, PHP memory, and CPU?
Workers set how many requests run at once, memory sets how much each worker can use, and CPU sets how fast the work runs.
A worker is a process, not a speed setting. Adding workers lets more requests run side by side, but it does not make one slow request finish sooner. Kinsta makes the same point: if CPU use stays low while threads fill up, the cause is slow queries or outside calls, not the thread count.
Memory is per worker. Kinsta lists 256MB per thread on most plans and 512MB on larger ones, as of November 2026. A worker that runs out of memory fails even if other workers are free, so a memory error is not fixed by adding workers.
CPU is the shared workhorse. A site can have free workers and still be slow if the CPU is saturated, and it can have a fast CPU and still queue if workers are full.
Check all three before you pay for an upgrade, and compare them with how many visitors shared hosting can handle if you are on a shared plan.
What mistakes should you avoid?
Do not buy more workers before you fix slow code, and do not judge a plan by visits alone.
The common mistakes are short. Buying workers for a slow checkout hides the slow query that caused the queue.
Setting pm.max_children far above your RAM invites out-of-memory errors. Treating a visit limit as a concurrency limit misleads you, because cached visits need no worker at all.
Also avoid judging a host only by its visit cap. A plan with a high visit limit and 2 workers can still queue during a sale, while a plan with fewer visits and more workers can handle a busy checkout hour.
Check the worker count, the memory per worker, and the price of extra workers before you choose. Our guide on how much WordPress hosting costs can help you weigh those trade-offs.
Frequently asked questions
How many PHP workers does a small WordPress blog need?
Most small blogs need 2 to 4 workers, because most logged-out traffic is served from cache and never reaches PHP. If your blog has many logged-in readers, comments, or search traffic, 4 workers is a safer starting point. Ask your host for the exact number on your plan.
Do PHP workers affect how many visitors my site can handle?
They affect how many uncached visitors can be served at the same moment, not your total monthly visits. Four workers can serve many thousands of cached visits a day, but only 4 uncached requests at once. Caching is what turns a small worker pool into a large visitor capacity.
Are PHP workers the same as PHP threads?
On most hosts, yes in practice. Kinsta calls them PHP threads, WP Engine calls them PHP workers, and both mean a process that handles one uncached request at a time. The underlying setting on your own server is pm.max_children in PHP-FPM, which sets the same limit.
Can I increase PHP workers on shared hosting?
Usually not directly, because the host sets the pool for the whole server. Some managed hosts let you change the thread count in the dashboard or buy a PHP performance add-on. On shared hosting, your main options are better caching, fewer uncached requests, or a plan with more workers.
Will more PHP workers make my WordPress site faster?
More workers help only when workers are the bottleneck, such as during a sale with many simultaneous checkouts. They do not speed up a single slow page, fix a slow database query, or add CPU power. Fix slow execution first, then add workers if requests still queue.
What error do you see when PHP workers run out?
You may see slow pages, spinning loaders, or broken AJAX calls first, then 502 or 504 errors once the queue fills. A 504 often means requests were evicted from the backlog, while a 502 often means a request ran too long and was killed. Check slow queries and uncached traffic before upgrading.
Sources
- How Kinsta handles PHP threads and caching for WordPress Kinsta
- PHP: FPM Configuration PHP.net
- Manage PHP Workers and Prioritization WP Engine
- Requirements WordPress.org
- PHP: Supported Versions PHP.net
- WordPress Hosting Add-Ons Kinsta Docs
Is your product missing, or something out of date?
Tell us what to add or correct. We read every note and reply when we need a source. A message does not buy a ranking.
Thanks — we review requests within 3 business days.
