Skip to content

Does WP Engine have cPanel? No — here is the migration runbook

WP Engine is a managed platform with a User Portal, SFTP and a scoped SSH gateway — not cPanel or WHM. What each side actually gives you, and the full cutover runbook for moving a WordPress site onto a cPanel host.

WP Engine does not have cPanel, and no add-on adds one. It is a managed WordPress platform: instead of cPanel and WHM you get the WP Engine User Portal, SFTP users you create per environment, a scoped SSH gateway on a separate hostname, and database access from the portal — no mailboxes, no MultiPHP Manager, no Cron Jobs screen, no root. So “wp engine cpanel” is almost always one of two questions: can I get cPanel-style control without leaving? — no — or what does it take to move this site onto a cPanel host? This guide answers the second, end to end.

The move is only partly a file copy. The archive WP Engine hands you contains wp-content/, a database dump, and a manifest — and none of the platform that was sitting in front of it. The real work is rebuilding that platform layer by layer on cPanel, then running a cutover whose order matters more than any single command in it. If you are leaving a GoDaddy Managed WordPress plan instead, the export mechanics differ and that path has its own guide.

What you’ll accomplish

  • A map from each WP Engine portal screen and platform layer to whatever replaces it on cPanel.
  • A working copy on cPanel, smoke-tested on the real domain before any DNS record changes.
  • A cutover sequence with a deliberate write freeze, so the two databases never diverge.
  • SSL issued on the cPanel side and mail routing decided before the MX records matter.
  • A rollback you can execute in minutes, and a clear statement of when it stops being cheap.

Prerequisites

You need portal access on the WP Engine side (to pull a backup point and export redirect rules), SSH or SFTP to the install, and a cPanel account with SSH enabled. WP-CLI on both ends saves hours; WP Engine’s gateway provides it, and most cPanel hosts ship it as wp.

Answer seven questions while the site is still live. The pre-migration inventory covers the same ground in checklist form for any source host.

  1. What PHP version is the site running? A site on PHP 8.2 dropped onto a cPanel account defaulting to 7.4 fails in ways that look like file corruption. Set the target in MultiPHP Manager first.
  2. How big is the database, table by table? Run wp db size --tables --size_format=mb. Anything over a few hundred megabytes changes the import method and the length of your window.
  3. Which plugins are on WP Engine’s disallowed list? A caching or backup plugin they block has not been doing in production what its settings screen claims. It will on cPanel, and may fight your new cache.
  4. What redirects live in the portal? They are applied above WordPress and are not in the backup. Export the list while the install still exists.
  5. Which environment are you migrating? Production, staging, and development are separate installs with separate databases. Confirm the backup point is production’s, and that nobody has treated staging as a second live site.
  6. Where does mail come from today? WP Engine hosts no mailboxes, so the MX records already point elsewhere and the site sends over SMTP or a transactional provider.
  7. What is the performance baseline? Measure TTFB and full page load now, so after cutover you compare against a number, not a memory.

Then lower the DNS TTL on the A and AAAA records to 300 seconds, at least 24 hours ahead. That turns a bad cutover from a multi-hour rollback into a five-minute one.

How it works

WP Engine is a platform, not a server, and the two control surfaces barely overlap. Environments, backup points, redirect rules, cache purges, SFTP users, and domains all live in the User Portal. Shell access is a gateway on its own hostname, scoped to a command set — WP-CLI, rsync, git, composer — rather than a login on the machine serving your site. There is no WHM, no root, no mailbox, and no way to park a second application beside WordPress in the same install.

cPanel inverts nearly all of that: File Manager and FTP accounts, Email Accounts and Email Routing, Cron Jobs, MySQL Databases and phpMyAdmin, MultiPHP Manager, SSL/TLS Status with AutoSSL, and — on most hosts — real SSH into the account. What you do not get is anything in front of PHP: no bundled CDN, no edge page cache, no platform quietly running backups and updates on a schedule you never set.

Map of the WP Engine User Portal surfaces against their cPanel counterparts, with the gaps on each side called out

That is the administrative view. The migration work lives in the runtime view: the archive gives you WordPress, not the machinery around it. The next diagram maps each platform layer onto what must exist on cPanel, flagging those with no direct equivalent.

Side-by-side map of WP Engine platform layers and their cPanel replacements, with layers that have no equivalent flagged

Five of them deserve more than a row in a table.

The page cache. WP Engine serves most anonymous traffic from a full-page cache sitting entirely in front of PHP. On cPanel there is no such layer until you build one — LiteSpeed Cache on a LiteSpeed host, or a PHP-level cache plugin plus a CDN on Apache. A theme that felt fine on WP Engine was measured with PHP mostly bypassed: that performance was the platform’s, not the code’s.

The injected mu-plugins. WP Engine adds must-use plugins to the running environment from outside the site, so they never appear in your archive. They define helpers and constants — is_wpe() and WPE_-prefixed constants among them — that theme or custom-plugin code sometimes calls. On cPanel those calls resolve to nothing, and an undefined function call is a fatal error, not a graceful degradation. Grep for them before you cut over, not after.

The CDN and the object cache. Their CDN is bundled and purged from their dashboard, and on eligible plans Object Cache Pro runs against Redis they operate. Neither has a cPanel equivalent. A CDN you supply yourself — Cloudflare in front of the origin is the common answer — and invalidation becomes a new job, including telling your cache plugin how to purge the edge on publish. For the object cache you need Redis on the server plus the Redis Object Cache plugin; check that Redis exists before planning around it, because many shared cPanel servers have none, and for a small site running without one beats faking it.

The disallowed plugin list. WP Engine blocks a defined set of plugins at the platform level — mostly caching, backup, and security plugins that duplicate or fight what the platform already does. A blocked plugin may sit in wp-content/plugins/ without doing what its settings screen claims, or may have been removed outright. Nothing on cPanel blocks it, so on first load it runs for real — and two full-page caches fighting over the same output is a reliable way to serve one visitor another visitor’s cart. Read wp plugin list against their published list, decide plugin by plugin what you want running, and delete the rest rather than leaving it deactivated.

Redirects and staging live outside WordPress. Redirect rules entered in the portal are applied above WordPress, so they are in neither the database nor the archive — export them before you cancel anything, because the list disappears with the install. Staging and transferrable installs are the same story in another shape: a portal-side copy mechanism between environments, with no cPanel equivalent. A staging subdomain and a promotion process become yours to define.

One more thing shapes the plan: WP Engine’s SSH access is a gateway, not a shell on the web server. It answers on a separate hostname, is scoped to WP-CLI, rsync, git and similar, and is the fastest way to pull a fresh uploads/ directory without waiting on another backup point.

Step-by-step

The order below is the part people get wrong. Everything before the freeze is rehearsal you can repeat; everything after it is live.

Cutover timeline showing what serves traffic at each stage, where writes land, and the point of no return

  1. Confirm what the WP Engine side will let you do. Prove WP-CLI answers over the gateway before planning around it. The username and hostname appear on the environment’s page in the portal.

    ssh install@install.ssh.wpengine.net "wp core version && wp db size --tables --size_format=mb | tail -20"

    You should get a WordPress version number followed by a table-by-table size list. A password prompt or rejected key means your public key is not registered on that environment; add it in the portal and retry. Without the gateway everything below still works — you fall back to the backup point and SFTP, and the delta sync in step 12 becomes a second full copy.

  2. Pull the backup and verify it before you trust it. Request a backup point in the portal, download the archive, and inspect it.

    tar -tzf wpengine-backup.tar.gz | head -40
    grep -c 'CREATE TABLE' wp-content/mysql.sql
    tail -5 wp-content/mysql.sql

    You should see the standard WordPress directories, a table count that matches the site, and a dump ending on a complete statement rather than mid-INSERT. A truncated dump imports without error and silently loses the tail of your largest table. Take the dump’s path from the tar -tzf listing rather than assuming it.

  3. Create the destination account, database, and PHP version. Use cPanel’s MySQL Database Wizard for the database and user, then set the PHP version in MultiPHP Manager to match the source. Extract the archive into a working folder in the account home, never over public_html.

    mkdir -p ~/wpe-migration && tar -xzf ~/wpengine-backup.tar.gz -C ~/wpe-migration
    du -sh ~/wpe-migration

    The reported size should be within a few percent of what the site used on WP Engine. A much smaller number means the archive was partial.

  4. Import the database at real size. phpMyAdmin gives up well before most production dumps finish, so import from the shell inside screen or tmux, so a dropped session does not abort halfway.

    mysql --max-allowed-packet=512M --default-character-set=utf8mb4 -u DBUSER -p DBNAME < ~/wpe-migration/wp-content/mysql.sql

    Success is silence. Verify with a table count rather than trusting the quiet exit:

    mysql -u DBUSER -p -e 'SELECT COUNT(*) FROM information_schema.tables WHERE table_schema="DBNAME";'

    The count should equal the CREATE TABLE count from step 2.

  5. Write a fresh wp-config.php. Do not reuse the archive’s. Copy your custom constants by hand, drop every WPE_-prefixed constant, generate new salts, add the cPanel database credentials, and set WP_CACHE to false until you have chosen a replacement cache.

    grep -n 'WPE_\|WP_CACHE\|DB_NAME' ~/public_html/wp-config.php

    The only matches you want are your own DB_NAME line and WP_CACHE. Any surviving WPE_ constant means you copied rather than rewrote.

  6. Remove the platform drop-ins and hunt for WP Engine-only code. The cache drop-ins in wp-content/ reference infrastructure that is gone.

    rm -f ~/public_html/wp-content/object-cache.php ~/public_html/wp-content/advanced-cache.php
    grep -rn 'is_wpe\|wpe_\|WPE_' ~/public_html/wp-content/themes/ ~/public_html/wp-content/plugins/ | grep -v vendor/

    An empty grep result is what you want. Every line it returns will fatal once the platform helpers are gone — reimplement the behaviour or delete the call.

  7. Run search-replace for the domain, then again for the CDN hostname. The site was served from a .wpengine.com hostname and, for assets, from a CDN hostname — both baked into the database.

    wp search-replace 'siteexample.wpengine.com' 'example.com' --all-tables --dry-run --report-changed-only
    wp search-replace 'siteexample.wpengine.com' 'example.com' --all-tables --precise

    The dry run prints a table of counts ending in a “Success: N replacements to be made” line. Read them before running it for real. wp search-replace walks serialised data correctly, which hand-written SQL does not — the serialisation problem explains what breaks when you skip it. Repeat the pair for the CDN hostname, and once more for http:// to https:// if the old site was mixed. The official WP-CLI reference documents every flag.

  8. Choose and configure the caches before cutover, not after. On a LiteSpeed host install LiteSpeed Cache; the Enterprise versus OpenLiteSpeed distinction matters, because only the commercial build supports the full page-cache feature set. On Apache, pick a PHP-level cache plugin. Then confirm Redis before configuring an object cache:

    redis-cli ping

    PONG means you have a local Redis and can install the Redis Object Cache plugin against it. A connection-refused error means the object cache layer simply goes away — survivable for most sites, not for a busy WooCommerce store.

  9. Rebuild the redirect rules that lived in the portal. Translate the exported list into .htaccess rules or a redirect plugin, then test each rule against the cPanel IP before cutover. -k skips certificate validation, since the destination has no matching certificate until step 13:

    curl -skI --resolve example.com:443:203.0.113.10 https://example.com/old-path/ | grep -i '^HTTP/\|^location:'

    You want the status line plus a location: header naming the new URL — a 301 for a permanent move, 302 only where you meant one. A 200 means the rule never fired and WordPress answered instead. A redirect that silently 404s is the most common post-cutover surprise: it worked right up until the platform holding it disappeared.

  10. Decide mail routing before the MX records move. WP Engine hosts no mail, so your MX records point at a mailbox provider. When the domain lands on a cPanel account, cPanel treats it as a local mail exchanger by default and swallows mail addressed to it.

    dig +short MX example.com
    grep -x 'example.com' /etc/localdomains /etc/remotedomains

    If dig returns an external provider, the domain must be in /etc/remotedomains, not /etc/localdomains — set it in cPanel’s Email Routing screen as Remote Mail Exchanger. Site-sent mail should go through SMTP regardless; see configuring WP Mail SMTP.

  11. Smoke test on the real domain without changing DNS. Force resolution client-side rather than editing hosts files on every machine:

    curl -skI --resolve example.com:443:203.0.113.10 https://example.com/

    You want HTTP/2 200 from the cPanel IP; the certificate will not match until step 13. Then walk it in a browser: checkout, contact form, admin login, sitemap, and one instance of every custom post type.

  12. Freeze writes, sync the delta, then flip DNS. Put the WP Engine site into maintenance mode or otherwise stop accepting orders and comments. Re-export the database, re-import it, re-run search-replace, and pull the uploads that arrived since your first copy:

    rsync -avz --delete install@install.ssh.wpengine.net:sites/install/wp-content/uploads/ ~/public_html/wp-content/uploads/

    rsync finishes with a transferred-bytes summary; a second run should report almost nothing new. Only then change the A record to the cPanel IP. During propagation both hosts answer — no DNS cutover exists without that window, which is precisely why the freeze exists.

  13. Run AutoSSL once the domain resolves at cPanel. AutoSSL validates over HTTP against the live domain, so it cannot issue a certificate before DNS points at the server. In cPanel, open SSL/TLS Status, select every domain and subdomain, and run AutoSSL.

    uapi SSL installed_hosts | grep -A2 'domains'

    Every hostname the site serves — apex, www, any subdomain — must appear. A certificate covering example.com but not www.example.com warns half your traffic. cPanel’s documentation portal covers the AutoSSL provider options if the default provider refuses a name.

The rollback

Keep the WP Engine install intact and paid for until you are certain — deleting it is the one irreversible act in the whole process. If something breaks badly in the first hours, revert the A record; at a 300-second TTL most resolvers follow within minutes, and WP Engine is still serving the same site it was yesterday.

That rollback is free only while the cPanel copy has taken no writes. The moment a real order, comment, or form submission lands on the new host, reverting DNS means reconciling those rows by hand or losing them. That boundary — not the DNS change — is the point of no return, and why the freeze in step 12 is worth the inconvenience.

Decide before cutover night who reverts, on what symptom, and by what clock: a rollback plan for a failed cutover covers writing one somebody else can execute at three in the morning.

Validate it works

Run these on the cPanel side once DNS has settled:

wp option get siteurl && wp option get home
wp plugin list --status=must-use --field=name
wp core verify-checksums
wp db check
wp cron event list --fields=hook,next_run_relative | head -20

siteurl and home must be the final domain, never the .wpengine.com hostname. The must-use list should hold only files you placed in wp-content/mu-plugins/ yourself — WP Engine’s were injected by the platform and never travelled in the archive, which is why code that called them now fatals. verify-checksums should report success; anything it flags did not transfer cleanly. wp db check should report OK for every table. The cron list should show sane next-run times: WP-Cron fires on traffic, so if WP Engine ran cron at the system level and cPanel does not, scheduled publishing stops quietly. Add an entry in cPanel’s Cron Jobs screen and set DISABLE_WP_CRON to true if so.

Then check the outside view:

curl -sI https://example.com/ | head -20
dig +short example.com @1.1.1.1

Look for a 200, a cache header from whichever cache you installed, and the cPanel IP from a public resolver. Then test transactional mail properly — a password reset, a contact form, and an order confirmation, not one of the three — and submit the sitemap from the new host so crawl errors surface in the first week rather than the fourth. The post-migration smoke tests list the browser-side checks no command stands in for.

Troubleshooting

Fatal error naming an undefined wpe_ function or is_wpe. Your theme or a custom plugin called something WP Engine defined in its injected mu-plugins. The grep in step 6 finds every instance; reimplement the behaviour or remove the call. It surfaces on specific templates, so a homepage that loads proves nothing.

Every image 404s but pages render. Asset URLs still point at the WP Engine CDN hostname, or uploads/ transferred with the wrong ownership. Check ls -la wp-content/uploads/ for files owned by a different user, then re-run search-replace against the CDN hostname — a separate string, easy to miss. Search-replace after a domain change walks the full set.

The MySQL import stops partway with a packet error. The dump holds a row larger than max_allowed_packet. Re-run with --max-allowed-packet=512M as in step 4, or split the dump by table. If the database is on a separate host, check the MySQL port and firewall before blaming the dump.

Mail to the domain vanishes after cutover. cPanel is treating the domain as a local mail exchanger while your MX records point elsewhere, so Exim delivers into local mailboxes nobody reads. Fix the routing as in step 10, then send a test message from outside and confirm it arrives.

AutoSSL refuses to issue for one hostname. Almost always a DNS record that has not moved or a subdomain that no longer resolves. Confirm each name resolves to the cPanel IP, remove names the site no longer serves, and re-run. Expect mixed-content warnings until the certificate covers everything — fixing mixed content after an SSL move covers the WordPress side.

When this is the wrong approach

If what you want is cPanel itself — the File Manager, the mailboxes, the ability to run something that is not WordPress on the same account — no WP Engine plan or add-on provides it, so moving is the only route. Test the requirement first, though: mailboxes can be bought from a mail provider and pointed at the same domain without touching where WordPress lives, and a second application can live on a second host.

If the only motivation is cost, price the replacement honestly first: you are taking on the page cache, the CDN, the object cache, the backups, the update cadence, and the security posture that were somebody else’s job. For a brochure site that is a reasonable trade; for a site that takes orders with nobody assigned to own those things, an unmanaged cPanel box trades a predictable bill for an unpredictable outage.

If the motivation is control — a plugin they disallow, a PHP extension they do not offer, a cron schedule you need to own, root access — the move is justified, and the stack map above is your scope of work.

Coming from Kinsta instead, the shape is similar but the export differs; see migrating from Kinsta to cPanel. Stack Harbor runs WP Engine to cPanel cutovers as a fixed-scope migration engagement.

Running WordPress that earns real money deserves an operator — Stack Harbor runs that stack under Enterprise WordPress; book an infrastructure consult.