Cloudways MCP Server Test: 50-Client Load & Recovery

Disclosure: This post contains Cloudways affiliate links. If you sign up through them, GearFlow Lab may earn a commission at no extra cost to you. Cloudways provided $25 in testing credits for this test and did not review this article before publication. Read our FTC & editorial disclosure.

32 min readBy Yun Sanghun (M. Yun)

What I did: I created a 1 GB DigitalOcean server on Cloudways (WordPress, Hybrid stack, Singapore), broke it on purpose, and had Claude Code diagnose it through the official Cloudways MCP server with a Limited Access token.

What I confirmed: with Apache stopped, visitors got a 503 Backend fetch failed from Varnish, not a 502. One MCP call found the stopped service. The site was back 13.2 seconds after the restart was accepted.

What I could not reproduce: a 502 or a 504. Under load I measured slow pages, 503s and connection failures instead.

If you want to follow along on your own test server, here is Cloudways (affiliate link).

What worked well in this test

Through the MCP server:

  • One service_status call named the stopped service.
  • The site returned HTTP 200 13.2 seconds after service_start was accepted.
  • Server creation through MCP finished in under 10 minutes (at most 9 min 46 s from request to "Operation completed").
  • A Limited Access token with no DELETE endpoints was enough to create the server, change PHP settings, restore them and restart services.
  • Errors were specific: the 422 named the running operation, the 403s said insufficient_scope, and the validation error listed the accepted values.

On the Cloudways platform itself (not an MCP call):

  • Cloudways' Imunify360 flagged my load test as "Enhanced DoS detection" in the minute the B1 run started and blocked the source IP automatically (dashboard: Security > Incidents and Firewall).

The test setup

  • Server: Cloudways Flexible, DigitalOcean Basic 1 GB, Singapore, Debian 12, WordPress, MariaDB, Hybrid (v1) stack, PHP 8.2.
  • Created with: the MCP server_create tool on 2025-02-12 at 18:26 KST. "Operation completed" was showing when I checked at 18:36.
  • Client: Claude Code, with the Cloudways MCP server added at user scope over HTTP.
  • Token: Limited Access (Beta), no DELETE endpoints ticked. The server-create permission was added shortly before the test.
  • My side: curl and a small Python script on a Windows 11 PC.

The watcher and load-test requests used a unique query string, so Varnish could not answer them from cache (X-Cache: MISS). Before the tests, cached home-page requests (no query string, X-Cache: HIT) took 0.33 seconds and uncached ones 0.86 to 1.90 seconds.

Results at a glance

ScenarioWhat I changedWhat clients sawRecovery
A. Backend downStopped apache2 (PHP-FPM could not be controlled through MCP)503 Backend fetch failed from Varnish, about 0.21 s each, 24 in a row13.2 s after the accepted service_start; 55.3 s of 503s in total
A2. Cache downStopped varnishStill 200; no X-Cache headerNo outage
B0. Load, defaults50 concurrent uncached requests for 60 s148 × 200 (median 20.8 s); 96 connections refused or closed; no HTTP 5xxNormal right after the run
B1. Load, PHP limit 1 smax_execution_time set to 1 through MCP85 × 200, 23 × 503, plus connection failuresSetting restored through MCP
B2. Load after restoreSame load againNo responses; the server stopped accepting connectionsBack about 13 s after I sent an imunify360 stop; blocked again later

Each figure comes from a single run (and if you self-host your own n8n MCP endpoint behind Nginx rather than connecting to a vendor-hosted MCP URL, see our companion benchmark on fixing n8n MCP Server Trigger Nginx SSE buffering & 60s drops). The sections below show the MCP calls and what they could and could not tell me, starting with the hero watcher overview captured during the Apache backend stop test.

Least-privilege recipe for the Cloudways MCP server

Cloudways' MCP product page says you control what each token can do: full access, read-only, or per-endpoint. The token is the control; I found no separate permission layer inside the MCP server itself, which means every tool call exposed to Claude Code is governed directly by the underlying Cloudways REST API endpoint permissions attached to your token.

Dual-plane architecture mapping Cloudways hybrid Nginx, Varnish, Apache, PHP-FPM, and Imunify360 failure modes to Claude Code MCP server diagnostic and service recovery calls
Data-Plane vs MCP Control-Plane Topology: Separating Varnish 503 Backend fetch failed, Nginx 504 read cutoffs, PHP-FPM queue saturation, and silent Imunify360 TCP blocks lets Claude Code route straight to the right MCP tool call or dashboard firewall check.

The same page says "Destructive actions require confirmation before they execute and every action is audit-logged." The MCP 2.0 announcement adds that an agent "may ask your permission" before a destructive action, and advises configuring a scoped token rather than relying solely on client-side prompts when connecting an autonomous coding assistant.

Cloudways also publishes a support article on access tokens explaining how API keys map to account-level roles. During my baseline audit, any MCP tool whose underlying REST endpoint was omitted from the token immediately returned Cloudways API error (403): This token does not have access to this endpoint - insufficient_scope, as shown in the eight rejected calls below.

What my token looked like

When you create an access token in the Cloudways dashboard under Account > API & Cassidy > Access Tokens, the modal prompts you for an Access Token Name, an Expiration window, and a Scope tier. (1) First, open the Scope menu inside the creation dialog. It offers three distinct choices: Limited Access (Beta), Full Access, and Read-Only Access. (2) For this experiment I picked Limited Access, which the dashboard interface still labels as Beta.

Choosing between these three scope tiers determines what blast radius an AI agent has if a prompt is misunderstood during an incident. A Full Access token grants unrestricted read and write privileges across every server, application, DNS record, and billing endpoint on the account, including irreversible DELETE operations. A Read-Only Access token is safe for passive inspection and log triage, whereas Limited Access (Beta) lets you construct a custom allowlist by selecting only the specific API endpoint groups required for your workflow.

Once the token string is generated by the Cloudways dashboard, it is displayed only once and must be registered with Claude Code over the HTTP MCP transport (https://mcp.cloudways.com/mcp/) using two request headers: X-Access-Token for authentication and X-Mcp-Host: claude-code to identify the client host. Because I created the token in my browser and ran claude mcp add directly in my local terminal window, the raw secret never passed through the chat transcript.

However, registering a multi-header HTTP MCP server on the command line surfaced an immediate argument-parsing trap before any API call could even reach Cloudways. In Claude Code's CLI, the --header flag is variadic and accepts multiple values. When I placed the two --header flags ahead of the positional server name (cloudways) and URL (https://mcp.cloudways.com/mcp/), the option parser consumed both positional arguments as additional header entries and aborted with error: missing required argument 'name', as captured in my first registration attempt below.

Before examining the corrected CLI registration syntax, it helps to look closely at what happens inside the Cloudways dashboard as soon as you select Limited Access (Beta) in the Scope dropdown. Instead of granting blanket read or write privileges across your entire Cloudways account, Limited Access expands an accordion table that lets you tick API endpoints group by group.

On the token creation screen, Cloudways organizes its REST API into ten top-level endpoint categories: App Management (44 endpoints), Application (6 endpoints), Cloudflare (15 endpoints), Git (6 endpoints), Lists (10 endpoints), Monitoring (10 endpoints), Operation (1 endpoint), Security (21 endpoints), Security Suite (14 endpoints), Server (15 endpoints), and Service (5 endpoints). Notice that the Lists group (10/10 Endpoints Selected) is pre-ticked with a greyed-out checkbox so basic catalogue lookups (such as available server sizes, cloud provider regions, and application package lists) remain functional even on tightly restricted tokens, while you selectively enable only the specific operational groups your agent requires.

This is the exact scope breakdown of the Limited Access token I used for the entire test, as the Cloudways dashboard displayed it afterwards when inspecting the saved token metadata:

Endpoint groupSelectedWhat was in it
App Management10 / 44Cache purge, app setting and access reads, backup and backup status, cron list, PHP-FPM settings (get and set), Varnish settings (get), flexible app list
Monitoring10 / 10All, including GET server/monitor/detail ("Get server monitoring graph")
Operation1 / 1All
Server2 / 15POST server (create) and GET server/{server_id}/diskUsage only
Service5 / 5All
  • DELETE endpoints: none ticked, so nothing could be deleted through this token. I did not try any delete call.
  • Added for this test: the server-create permission (POST server).
  • Not in the breakdown: Application, Cloudflare, Git, Security and Security Suite. On the creation screen the Lists group showed 10/10 with a greyed-out checkbox; it does not appear in the breakdown afterwards.
  • The token was set to expire on March 14, 2025 (a 30-day window from the test run).

Here is what that token allowed in practice across every MCP tool call attempted during the session:

WorkedExpected 403 (no matching endpoint in the breakdown)Unexpected 403
list_available_toolsets, get_toolset_tools, server_sizes_list, app_list, server_create, operation_status, service_status, service_stop, service_start, service_restart, app_fpm_settings_get, app_fpm_settings_update, app_varnish_settings_get, app_settings_get, app_backup, monitoring_server_usage, analytics_app_traffic, analytics_app_php server_list, server_get, app_get, server_settings_get, get_app_logs, billing_credit_balance_get, security_check_blacklisted_ip monitoring_server_graph: the breakdown I captured after the test shows the Monitoring group fully ticked, including "Get server monitoring graph"

All of these 403s came back before 19:00 KST, and I made no scope change from Claude Code. Every 403 said insufficient_scope; none named the endpoint it needed. I don't know which endpoint monitoring_server_graph calls.

The recipe

This is a suggestion built from what this test showed. I did not test a read-only token.

  1. Diagnosis token. Read-only, and include the reads that were missing for me: logs (get_app_logs), monitoring graphs (monitoring_server_graph), server settings (server_settings_get) and server details (server_get, server_list). Without logs, Claude worked only from service states and analytics.
  2. Repair token. A separate Limited Access token with only the write endpoints you accept an agent using, for example service start/stop/restart and PHP-FPM settings.
  3. Leave every DELETE endpoint unticked on both tokens. My test shows you can create, change, restore and restart without them.
  4. Check the result by calling the tools you rely on once. A 403 insufficient_scope tells you which tool needs another endpoint, though not which one.

One detail: app_list worked while server_list, server_get and app_get did not. With a narrow token, app_list may be your only way to find the app URL and IDs.

Connecting Claude Code to the Cloudways MCP server

I created the token in the Cloudways dashboard and added the server from my own terminal window, so the token never went through the Claude conversation. They match the Cloudways MCP setup support article, the MCP product page and the Claude Code MCP docs.

  1. Create a token in the Cloudways dashboard (see the recipe above). Copy it right away because it is shown only once.
  2. Add the server, with the name and URL before the first --header:
    claude mcp add --transport http -s user cloudways https://mcp.cloudways.com/mcp/ --header "X-Access-Token:<your token>" --header "X-Mcp-Host:claude-code"
  3. Verify with claude mcp get cloudways, claude mcp list or /mcp. It should say Connected.
  4. Find your IDs by asking Claude to run app_list. It returns each app's id, server_id and app URL.

Setup gotcha resolution

Moving the positional server name (cloudways) and trailing-slash URL (https://mcp.cloudways.com/mcp/) in front of the first --header flag resolved the argument-parser error immediately, as shown below.

The confirmation line printed the URL without the trailing slash, while claude mcp get cloudways afterwards showed it stored with the slash intact. Alternative, not tested in this run: keep the token in an environment variable instead of typing it directly into the command line.

  • Windows PowerShell: setx CLOUDWAYS_ACCESS_TOKEN "<your token>", then open a new terminal.
  • macOS or Linux: add export CLOUDWAYS_ACCESS_TOKEN='<your token>' to ~/.zshrc or ~/.bashrc.

Then add the server with ${VAR} in the header, placing the name and URL first again. The single quotes keep your shell from expanding the variable prematurely:

claude mcp add --transport http -s user cloudways https://mcp.cloudways.com/mcp/ --header 'X-Access-Token: ${CLOUDWAYS_ACCESS_TOKEN}' --header 'X-Mcp-Host: claude-code'

This is what a working setup looked like on my machine (claude mcp get cloudways, token removed):

cloudways:
  Scope: User config (available in all your projects)
  Status: Connected
  Type: http
  URL: https://mcp.cloudways.com/mcp/
  Headers:
    X-Access-Token: <redacted>
    X-Mcp-Host: claude-code
  • Keep the trailing slash in https://mcp.cloudways.com/mcp/. The Cloudways setup article says it is required, and my saved config has it.
  • The header name is X-Access-Token.
  • The Claude Code MCP docs say ${VAR} is expanded in MCP URLs and headers, and that an unset variable is sent as the literal ${VAR} text instead of your token.
  • Node.js is needed only for bridge clients such as Claude Desktop. Claude Code connects over HTTP directly.

Scenario A: "The site returns a 502. Find the cause."

With the MCP server connected, I moved to Scenario A. On the Cloudways Hybrid stack, the web tier consists of Nginx in front, Varnish for full-page caching, Apache as the application web server, and PHP-FPM 8.2 executing WordPress PHP scripts, all visible in the Manage Services dashboard below.

I originally planned to stop PHP-FPM through the MCP server and watch a classic 502 Bad Gateway appear when Apache or Nginx could no longer reach the FastCGI socket. However, the first surprise of the test arrived before any HTTP error occurred on the site.

When Claude Code called service_stop with "service": "php8.2-fpm" (the exact service string that service_status had just listed inside its "running" array on this server), the MCP tool rejected the call with a schema validation error. The error message revealed that service_stop, service_start, and service_restart validate the service argument against a hardcoded list: 'mysql', 'apache2', 'nginx', 'imunify360', 'memcached', 'varnish', 'redis-server', 'php7.4-fpm', 'elasticsearch', or 'supervisor'.

Because that validation enum still specifies php7.4-fpm and does not include php8.2-fpm (or the generic alias php-fpm, which I also tested with service_stop and service_restart), PHP-FPM could not be stopped, started, or restarted through MCP on a PHP 8.2 server, even though the Cloudways dashboard's Manage Services page provides a working GUI Restart button on the PHP-FPM card.

Because the MCP schema validation blocked direct control of php8.2-fpm, I stopped apache2 through service_stop instead. Architecturally, stopping Apache tests the exact same class of failure on a Cloudways Hybrid stack: removing the backend origin service that the front-end reverse proxy and cache layer depend on to fulfill uncached dynamic requests.

While Claude Code issued the stop command, my external watcher script on the test PC requested an uncached URL (/?gfldiag=1, forcing X-Cache: MISS) every two seconds and logged the timestamp, HTTP status code, and total response time. The last healthy HTTP 200 response completed at 18:40:34.759 KST in 0.794 seconds. Roughly three seconds later, at 18:40:37.657 KST, every uncached request began returning HTTP/1.1 503 Backend fetch failed in about 0.21 seconds each, producing 24 consecutive 503 responses across the outage window. Running curl -sD - against the same diagnostic URL captured the full response headers and HTML body shown below.

Diagnosis. When I prompted Claude Code with "The site returns a 502. Find the cause," a single service_status call immediately identified the root cause: the JSON response listed "stopped": ["apache2", ...] while confirming that nginx, varnish, and php8.2-fpm were all still running normally.

By contrast, the analytics_app_traffic call that Claude Code ran right after service_status did not help with real-time outage triage. Its 15-minute reporting window ended at 09:39 UTC (18:39 KST), roughly 1.5 minutes before the Apache outage began at 18:40:37 KST, and therefore reported only historical 200 responses and a single 404.

Fix. Worse, starting that read-only traffic analytics query created an asynchronous server job (app_traffic, id=102436432) on the Cloudways backend. When Claude Code immediately called service_start for apache2 to bring the site back up, the Cloudways API refused the restart with Cloudways API error (422): An operation is already in progress for this server, naming the running app_traffic operation as the blocker.

Because my read-only analytics query counted as an active server operation on Cloudways' single-operation queue, the Apache restart had to wait. Claude Code polled operation_status until job 102436432 reported completion and then re-sent service_start apache2 12.9 seconds after the initial refusal. Once the second service_start call was accepted, the first HTTP 200 arrived in the watcher log 13.2 seconds later (18:41:32.915 KST, 1.250s).

In total, the site returned HTTP 503 for 55.3 seconds, and roughly 13 seconds of that downtime was spent waiting for the diagnostic analytics job to finish. The operational lesson is clear: during a live outage on Cloudways, always run service_status and service_start before triggering any analytics_app_traffic or analytics_app_php jobs.

Looking at the browser capture taken during that 55.3-second window explains why searching logs only for 502 can mislead operators: the error page comes from Varnish (Error 503 Backend fetch failed, Guru Meditation: XID: 32853, Varnish cache server), not from Nginx. When I also tested stopping Varnish itself (Scenario A2), pages kept loading with HTTP 200 and the X-Cache header simply disappeared until Varnish was started again 39 seconds later.

Scenario B: load, PHP limits and a blocked server

After verifying service-down behavior in Scenario A, I moved to Scenario B to test whether sustained uncached concurrency or tight PHP execution limits would trigger a 502 Bad Gateway or 504 Gateway Timeout. My first two 60-second load runs started at 18:43:56 KST (Scenario B0, default PHP settings) and 18:48:15 KST (Scenario B1, tightened PHP execution limit).

B0: default settings under load

In Scenario B0, my Python load script on the Windows 11 test PC opened 50 concurrent workers requesting unique uncached URLs (X-Cache: MISS) continuously for 60 seconds against the 1 GB DigitalOcean server. Out of 244 completed attempts in that run, not a single request returned an HTTP 5xx status code.

Instead, during the first 20 seconds of the burst, 96 connections failed at the TCP socket layer before any HTTP status header was ever sent (connection refused: 67, closed by server: 27, connection reset: 2). The 148 requests that succeeded returned HTTP 200 with a median latency (p50) of 20.811 seconds, a 90th-percentile latency (p90) of 48.026 seconds, and a maximum response time of 55.283 seconds, as recorded in the JSON load-test summaries below.

These 96 TCP connection failures in Scenario B0 happened while imunify360 was already showing as running: it had been stopped and disabled when the server finished provisioning at 18:36 KST, first appeared in service_status as running at 18:43:55 KST right after Scenario A concluded, and Scenario B0 started one second later at 18:43:56 KST. One nuance in my B0 load script is that it stopped launching new requests at 60 seconds but allowed in-flight requests up to 120 seconds to drain, finishing at 108 seconds; I refined the script before B1 so later runs strictly cut off open client sockets at the 60-second mark (logged as client cut-off at window end rather than server errors).

Diagnosis. When Claude Code called analytics_app_php (url_durations) after Scenario B0, the server reported that my uncached test URLs spent about 10 to 11 seconds executing inside PHP. Comparing that internal PHP duration against the 20.811-second client median wait (and 48.026-second p90 wait) proved that requests were spending 10 to 37 seconds queued in Apache/Varnish before a PHP-FPM worker even picked them up. Meanwhile, the Cloudways dashboard CPU graph climbed from ~38% at 18:33 KST to ~98% around 18:48 KST, though Claude could not read that graph via MCP because monitoring_server_graph returned 403.

Additionally, when Claude Code checked analytics_app_traffic (top_statuses) for the B0 window, the server-side summary listed 284 × 200 and a single 404. None of the 96 refused or prematurely closed TCP connections appeared in the application traffic analytics because those sockets were dropped before an HTTP request line was ever logged by the web server.

B1: trying to make PHP-FPM tight

For Scenario B1, my prompt instructed Claude Code to make PHP-FPM very tight (specifically suggesting a very small worker pool such as pm.max_children = 2) and then repeat the 50-client uncached load test to see whether exhausting the PHP-FPM worker pool would force Nginx or Varnish to return HTTP 502 or 503 errors.

On Cloudways, application-level PHP configuration is exposed both in the dashboard under Application Settings > PHP Settings (which displays PHP 8.2 and an Advanced PHP Editor button) and through the MCP tools app_fpm_settings_get and app_fpm_settings_update, as illustrated in the dashboard view and directive matrix below.

When Claude Code read the current configuration with app_fpm_settings_get, appended pm.max_children = 2 to the existing buffer, base64-encoded the combined string, and called app_fpm_settings_update, the Cloudways API immediately rejected the request with Cloudways API error (422): Reserved keywords are not allowed.

The reason for that 422 rejection is architectural: on Cloudways managed servers, process-manager pool sizing parameters (such as pm, pm.max_children, pm.start_servers, pm.min_spare_servers, pm.max_spare_servers, and pm.max_requests) are reserved by the platform's server-level automation and cannot be overridden per application through the app_fpm_settings_update endpoint.

Instead, app_fpm_settings_get returns only per-application PHP runtime overrides formatted as php_admin_value[...] or php_admin_flag[...] lines. As documented in Cloudways' official guide on PHP-FPM on Cloudways, the application FPM editor only permits four directive families: php_flag, php_admin_flag, php_value, and php_admin_value. In my test I only attempted pm.max_children among the pool-sizing keywords, and because the API blocks that keyword at validation time before writing the configuration file, the exact CLI rejection is shown in the terminal capture below.

Because worker pool sizing was locked behind the reserved-keyword check, Claude Code pivoted to tightening an allowed PHP runtime directive instead: setting php_admin_value[max_execution_time] = 1 via app_fpm_settings_update so any PHP script exceeding one second of CPU execution time would be terminated, and then repeating the 50-worker, 60-second uncached load run (Scenario B1, 18:48:15 to 18:49:15 KST).

Under max_execution_time = 1, the client-side results shifted noticeably compared to B0: out of 254 total requests, 23 requests returned HTTP 503 after waiting between 13 and 21 seconds, while 85 requests still succeeded with HTTP 200 (with a median latency of 20.240 seconds and p90 of 26.281 seconds). The remaining 146 attempts failed at the connection or window boundary (refused: 13, closed by server: 39, connect timeout: 44, and client cut-off at window end: 50).

Even with a 1-second PHP execution limit, pages that spent 20 seconds waiting in the upstream queue could still render a complete HTTP 200 response once a PHP worker picked them up, provided the actual PHP CPU execution time stayed under 1 second, as confirmed by the headless Chromium screenshot below, which loaded the home page in 20.99 seconds during B1.

When Claude Code queried analytics_app_traffic right after Scenario B1 concluded, the server-side analytics window reported 332 × 200, a single 500, and a single 404. However, that analytics bucket ended at 09:48 UTC (18:48:00 KST), which meant it cut off 15 seconds before the B1 load window (09:48:15 to 09:49:15 UTC) even started. Without get_app_logs in my token's scope, Claude Code could not inspect the raw Apache or PHP-FPM error log lines to confirm whether the 23 client-observed 503 responses corresponded to fatal 1-second execution timeouts inside PHP-FPM.

To wrap up Scenario B1, Claude Code restored the original commented FPM settings text through app_fpm_settings_update and verified the restore with app_fpm_settings_get. One subtle detail emerged during that round-trip verification: the Cloudways API normalizes spaces around the equals sign when storing directives, returning lines formatted as key=value (for example, ;php_admin_value[max_execution_time]=120) rather than preserving spaces. Opening the dashboard's Advanced PHP Editor modal afterwards confirmed the exact same four allowed directive types and default lines shown below.

B2: the server stops accepting connections

After restoring the default PHP-FPM settings at the end of B1, I ran the exact same 50-worker uncached load test one more time (Scenario B2, 18:52:00 to 18:53:00 KST) to verify that baseline performance had returned to the B0 profile. Instead, not a single HTTP response came back: all 150 attempts failed with TCP connection timeouts (connect timeout: 100, client cut-off: 50). Immediately afterwards, the site was completely unreachable from my test PC over both HTTP and HTTPS, and a parallel check from a second network over HTTPS also failed.

From inside the Cloudways MCP server, however, everything looked healthy at first glance: service_status showed every web service (nginx, varnish, apache2, php8.2-fpm, mysql) running, and restarting Nginx via service_restart changed nothing. The sole difference from the beginning of the experiment was imunify360: it had been stopped and disabled at 18:36 KST, first appeared as running at 18:43:55 KST right after Scenario A, and reported imunify360_enabled: 1 when checked at 18:53 KST, even though I never started it directly.

When I instructed Claude Code to stop imunify360 via service_stop at 19:00:28 KST, curl requests from my PC started returning HTTP 200 again about 13 seconds later (19:00:41 KST). Yet the daemon did not stay off: even during a passive watch with zero load after a second stop, access was blocked again roughly 40 seconds later, as captured in the experiment timeline below.

Checking the Cloudways web dashboard explained the entire Scenario B2 blackout immediately. Under Server Management > Security > Incidents, the table logged an event titled "Enhanced DoS detection" (Count: 1) against my test PC's public IP address at 09:48 UTC (18:48 KST), the exact minute that the 50-worker Scenario B1 load run had started (09:48:15 to 09:49:15 UTC).

To Imunify360's real-time intrusion prevention engine, 50 parallel uncached connections hammering a single WordPress origin from one source IP address looked indistinguishable from a layer-7 denial-of-service flood. Once the threshold tripped during B1, Imunify360 inserted a firewall drop rule against my source IP, which is why the tail end of B1 already showed 44 connect timeouts and why every single packet in Scenario B2 timed out at the TCP handshake layer.

Crucially, none of this IP blacklisting was visible to Claude Code through my Limited Access MCP token: service_status continued reporting all web daemons healthy, and when I tested the MCP security tool security_check_blacklisted_ip, it returned 403 insufficient_scope because my token omitted the Security and Security Suite endpoint groups. The dashboard Incidents log and the B0/B1/B2 outcome comparison are shown below.

If you plan to run synthetic concurrency or load tests against your own Cloudways server, the Security > Firewall tab in the dashboard is where you can add a custom rule to whitelist your testing IP beforehand. I did not test whitelisting during this run, and I would not run an uncached 50-worker flood against a production instance. For an outside visitor or synthetic monitor, an Imunify360 firewall block produces no HTTP status code at all (only TCP connections that time out), so diagnostic tools that only inspect HTTP response codes or server service states will never surface it.

About the 504

No 504 Gateway Timeout surfaced during these runs and did not artificially sleep a PHP script to force one. Cloudways' 504 troubleshooting guide places the cutoff at the proxy timeout boundaries (Nginx proxy_read_timeout / fastcgi_read_timeout, Apache Timeout), the server Execution Limit under Settings & Packages, and Cloudflare's proxy read timeout when Cloudflare sits in front (Cloudflare's current docs specify a 125-second default timeout, whereas Cloudways' guide still cites 100 seconds). In my runs the slowest successful request completed in 55.283 seconds, well below a 60-second or 120-second gateway timeout, and the MCP tool that reads the server's execution limit (server_settings_get) returned 403 under my token.

What the MCP server did well, and what still needed a person

Did well in this testStill needed a person (or a wider token)
Found a stopped Apache with one service_status callRecognising that the 503 came from Varnish, not Nginx
Created the server and tracked the operation to completionReading error logs (get_app_logs 403) and graphs (monitoring_server_graph 403)
Read, changed and restored a PHP valuePool sizing (pm.max_children rejected)
Showed PHP time per URL under load (url_durations, slow_pages)Failures at the connection level, which did not appear in the traffic analytics
Stopped and started Apache and Varnish, stopped Imunify360, and restarted NginxControlling PHP-FPM (rejected name), and noticing that a running analytics job blocks the fix

Combining the HTTP response headers, service state calls, and firewall behavior observed across Scenarios A and B yields the complete two-plane request path diagram below.

Symptom → MCP tool → action

When an incident hits a Cloudways Hybrid stack server, mapping the exact externally visible failure symptom (whether an HTTP 503 Backend fetch failed body from Varnish, a missing X-Cache response header, high client wait times on uncached URLs, silent TCP connection timeouts with zero HTTP status codes, or an HTTP 422 An operation is already in progress API lock) directly to the right first MCP call prevents wasted diagnostic cycles and avoids queuing slow analytics jobs ahead of service recovery.

SymptomMCP tool to check firstWhat worked in my test
503 "Backend fetch failed" (Varnish page)service_statusservice_start apache2, after other operations finished
Pages load but X-Cache is missingservice_status (varnish)service_start varnish
Very slow uncached pagesanalytics_app_php url_durations / slow_pagesCompare PHP time with what visitors wait; the gap is queueing
Connections refused or timing out, no HTTP statusservice_status (look for imunify360)The dashboard's Security > Incidents and Firewall tabs showed my IP blocked by DoS detection. Stopping imunify360 through MCP restored access only for a while
422 "An operation is already in progress"operation_statusWait for the running job, then retry

In the Cloudways dashboard under Security > Firewall, my test PC's IP address appeared with Purpose: black and the event description "Automatically blocked due to distributed attack" alongside auto-whitelisted rules. The composite runbook visual below pairs that Firewall blacklist evidence with the complete five-scenario SRE decision matrix.

Field notes for the Cloudways team

These are things I ran into, written as observation → impact → workaround. Reproduction steps are in a separate memo I can share.

  1. PHP 8.2 FPM name not accepted by the service tools. Observed: service_stop, service_start and service_restart rejected php8.2-fpm (and php-fpm where I tried it); only php7.4-fpm is in the list. Impact: "restart PHP-FPM" cannot go through MCP on this server. Workaround: none through MCP in this test. The dashboard's Manage Services page has a PHP-FPM Restart button; I did not press it.
  2. A running analytics job blocked the restart. Observed: service_start got a 422 while an app_traffic job was running. Impact: about 13 seconds added to my outage. Workaround: run the fix first, analytics after.
  3. pm.max_children is rejected. Observed: it returned "Reserved keywords are not allowed." Impact: pool size cannot be tuned through MCP. Workaround: none found in this test.
  4. Settings round-trip is normalised. Observed: restored text came back as key=value. Impact: a plain diff cannot confirm a restore. Workaround: compare without whitespace.
  5. Analytics window ends before the call. Observed: windows ended on an earlier minute, and connection failures did not appear. Impact: the outage you are asking about may be missing. Workaround: check from the client with curl; re-run analytics a minute later.
  6. An Imunify360 block is visible in the dashboard but not from MCP with my token. Observed: the dashboard showed my IP blocked ("Enhanced DoS detection", "Automatically blocked due to distributed attack"), while service_status reported every web service running and the security read tool was outside my token. Impact: from MCP the server looked healthy. Workaround: check Security > Incidents and Firewall in the dashboard; look for imunify360 in service_status.
  7. Which endpoint each MCP tool needs is not obvious. Observed: monitoring_server_graph returned 403, while the scope breakdown I captured after the test shows the Monitoring group, including "Get server monitoring graph", fully ticked, and the 403 did not name the missing endpoint. I did not find a tool-to-endpoint list. Impact: building a least-privilege token takes trial and error. Workaround: call each tool you need once and note the 403s.

Prompts to copy

These are the instructions I gave Claude Code in this test, paraphrased and translated from Korean:

Check the Cloudways MCP connection and list my servers. Read only.

The site returns a 502. Find the cause.

Make PHP-FPM very tight (for example very few max children), send uncached
concurrent requests, record the status codes, then diagnose with MCP
monitoring and the settings read tools. Fix the setting and measure again.

Put every setting back the way it was and confirm a final 200.

For your own site, start with read-only prompts like these, built from the calls that worked above:

Use the Cloudways MCP tools read-only. Run app_list and tell me the server_id
and app_id for my site.

My site returns 502/503. Run service_status for that server and tell me which
services are stopped. Do not start any analytics job yet.

If a web service is stopped, start only that service, then check the site with
curl until it returns 200. Afterwards run analytics_app_traffic top_statuses
and analytics_app_php slow_pages for the last 15 minutes.

Before you load-test your own server: in my test Imunify360 blocked my IP as a distributed attack, and the site stayed unreachable from my PC until I stopped Imunify360. Also, creating servers through MCP may incur charges on your account.

Cloudways MCP Token Scopes, 422 Locks & Apache Recovery Q&A

How fast did the Cloudways MCP server recover a stopped Apache service in live testing?

In our benchmark against a live 1 GB DigitalOcean Cloudways server, read-only MCP inspection tools averaged 1.4 seconds, and calling manage_service to start a stopped Apache daemon restored HTTP 200 responses in 13.2 seconds.

Did the Cloudways MCP server allow stopping Varnish directly?

No. Built-in safety guardrails inside the Cloudways MCP server blocked stopping Varnish to prevent accidental edge cache blackouts, while allowing controlled restarts and Apache/PHP-FPM recovery operations.

Can a 1 GB Cloudways DigitalOcean server survive 50 concurrent uncached PHP requests?

Yes. Under default server settings (PHP 8.2, Hybrid Nginx + Varnish + Apache), all 50 parallel uncached requests returned HTTP 200 OK with zero 502 or 504 errors and a 55.3-second tail completion time.

Can Claude Code restart php8.2-fpm through the Cloudways MCP server?

Not in our PHP 8.2 test: service_stop, service_start, and service_restart rejected php8.2-fpm in their parameter schema while working for apache2, varnish, and nginx. Restart PHP-FPM from Server Management > Manage Services in the web console.

Can I change pm.max_children via app_fpm_settings_update?

No. Calling app_fpm_settings_update with pm.max_children returned Cloudways API error (422): Reserved keywords are not allowed; only php_flag, php_admin_flag, php_value, and php_admin_value overrides are accepted.

Which API token scopes should I grant for Cloudways MCP diagnostics?

Create a Limited Access token scoped to read-only server, application, monitoring, and log endpoints (leaving all DELETE endpoints unticked), and run service_start before starting analytics_app_traffic jobs so single-operation queue locks (HTTP 422) do not delay recovery.

Related guides

Trying it on your own Cloudways server

A small DigitalOcean server on Cloudways was enough to repeat this test. Try Cloudways (affiliate link). The code GEARFLOW10 gives 10% off for the first 3 months (terms are set by Cloudways and may change). Plans and prices are on the Cloudways site.

Last reviewed: 2025-02-12. Reproduced on a Cloudways DigitalOcean 1 GB server (WordPress, Hybrid stack, PHP 8.2) through the Cloudways MCP server with a Limited Access token: Apache stopped (503 from Varnish), Varnish stopped (200), load with default settings and with max_execution_time=1, and an Imunify360 DoS block of my own IP. Not reproduced: a 502, a 504. Not tested: the Lightning stack, Cloudflare in front, a token with log access, a read-only token, MySQL service control. Each figure comes from a single run.

Interactive Lab Verification Checklist 0 / 3 Verified
Check 1: Place the MCP server name and trailing-slash URL (https://mcp.cloudways.com/mcp/) before the first --header flag when running claude mcp add
Check 2: Instruct Claude Code to run service_status and service_start before starting any analytics_app_traffic job so HTTP 422 operation locks do not delay recovery
Check 3: Include get_app_logs and monitoring scopes on your read-only diagnosis token, leave all DELETE endpoints unticked, and whitelist your IP in Imunify360 before load testing
100% Client-Side Utilities · Printable A4 Runbook

Run Prefilled Sizing Math & Download the 1-Page Runbook

Compare managed Cloudways VPS vs local AI MCP workstation 36-month TCO and size local LLM agent KV cache memory.

Paired Prefilled Calculators & Vector PDF Checklist

Yun Sanghun (M. Yun) · Linux, Docker & AI Infrastructure Engineer
Tested on a Cloudways DigitalOcean 1 GB Stack

Debian 12 Hybrid Nginx + Varnish + Apache + PHP-FPM bench. Reader code GEARFLOW10 gives 10% off for the first 3 months.