Skip to content
Climb Google Maps: Google Business Profile optimization.

WordPress

Google Says Don't Serve a 200 When Your Site Is Down. We Read What Six Popular WordPress Maintenance Mode Plugins Send

Google's John Mueller warned this week that a 'back soon' page served with a 200 status can get indexed or make your pages look like duplicates. WordPress itself sends the right code. Three of the six most-installed maintenance and coming soon plugins send a 200 in their default setup. Here is which, and a script to check your own site.

Road work and no entry signs on metal barriers across a wet street

Key takeaways

  • A WordPress maintenance mode page should return a 503 status code, because Google's John Mueller said this week that a 'back soon' page served with a 200 can be indexed or treated as a duplicate.
  • WordPress core already does it right: during updates it sends 503 with Retry-After: 600, and its database and fatal error pages send 500.
  • In the Nov. 17, 2026 versions we read, Maintenance (1 million+ installs) sends 503 only if you tick a box, Under Construction (500,000+) always sends 200, and Minimal Coming Soon (100,000+) keeps 503 for its paid version.
  • LightStart, SeedProd's maintenance mode and CMP's maintenance mode send 503 with a Retry-After header, while SeedProd's and CMP's coming soon modes are for sites not yet launched.
  • Google's own guidance is 503 for a closure of one or two days, a normal 200 placeholder home page only for longer closures, and never a 503 on robots.txt, which blocks all crawling.

If your site is down, whether it's in WordPress maintenance mode or something broke, it should answer with a 503 status code, not a normal 200. Google's John Mueller made the point this week in a LinkedIn reply, reported by Search Engine Roundtable on November 17, 2026: an error or "back soon" message sent with a 200 can show up in Google's results, and when every page shows the same text, Google can treat them as duplicates, which it crawls less often, so recovery can take a long time.

Most WordPress sites go into maintenance mode through a plugin, so we downloaded the six most-installed maintenance and coming soon plugins from WordPress.org on November 17 and read the code that decides the status code. Three send a 200 in their default setup. Here is what each does, what WordPress itself does, and a short script that tells you what your site sends while it's down.

Why does a 200 during downtime hurt?

A status code is the first thing a server tells a crawler. Google's status code documentation spells out the difference:

  • 200: Google passes what it received to indexing. A page that says "We'll be back soon" is, to Google, the new content of that URL. Search Console may flag it as a soft 404.
  • 503: Google ignores the content, slows its crawling, and keeps the pages already in its index. Pages that keep returning server errors are eventually dropped.
  • 403, 404 or 410: Google treats the page as gone and removes it. Never use these to take a site offline.

According to Search Engine Roundtable's report, Mueller said the first problem fixes itself when the content comes back, but the duplicate problem can take a while, because Google recrawls duplicates less often.

How long can a site return 503?

Google's guide to pausing or disabling a website gives the limits:

  • One to two days: return an informational page with a 503 status instead of the content.
  • Longer than that: keep an indexable home page with a 200 status as a placeholder, so people can find out what's going on.
  • Always: keep robots.txt working. Google says a 503 on robots.txt "blocks all crawling", and a robots.txt that disallows everything can remove the site from Search.

Google also suggests a Retry-After header with your best guess of when you'll be back, a plain static HTML error page with inline styles, and a message that tells visitors when to return and how to reach you.

What does WordPress itself send?

The right codes. In WordPress's current code (version 7.1.4 is the latest release):

  • During core, plugin or theme updates, WordPress writes a .maintenance file and shows "Briefly unavailable for scheduled maintenance". The function behind it, wp_maintenance(), sends 503 with Retry-After: 600 (ten minutes). A custom wp-content/maintenance.php page gets the same 503.
  • "Error establishing a database connection" is sent with 500.
  • "There has been a critical error on this website", the fatal error page, is sent with 500.

So if your site only goes down during updates or when something breaks, WordPress already does what Google asks. The risk comes from maintenance plugins you switch on yourself.

We searched WordPress.org's plugin directory for "maintenance mode" and "under construction", took the six with the most active installs, downloaded each one's current version and read the code that runs when the mode is on. We did not install them, so this is what the code does, not a live test.

Plugin (version read)Active installsStatus code by default
Maintenance by WebFactory (4.33)1 million+200. 503 only after you tick "Enable 503 (Service Unavailable) status code"; it's off by default.
SeedProd Coming Soon Page, Under Construction & Maintenance Mode (6.20.12)600,000+503 with Retry-After: 86400 in Maintenance Mode. Coming Soon mode doesn't send 503.
Under Construction (5.83)500,000+200, always, with a Retry-After header that means nothing next to a 200.
LightStart, formerly WP Maintenance Mode (2.6.26)400,000+503 with a Retry-After set from the plugin's countdown.
CMP Coming Soon & Maintenance (4.1.22)200,000+503 with Retry-After: 86400 in Maintenance mode. The default mode is Coming Soon, which doesn't send 503.
Minimal Coming Soon & Maintenance Mode (2.45)100,000+200. The plugin's own settings page lists 503 as a paid PRO feature.

Two details matter. "Coming soon" modes sending 200 is a reasonable choice for a brand-new site with nothing indexed yet; it's a problem only when an established site uses one to cover a short outage. And LightStart has a setting to let search bots past the maintenance page, which is another valid way to handle it: Google keeps seeing your real pages while people see the notice.

Our view: which setup to use

  • For an outage or maintenance of a day or two, use a mode that sends 503 with Retry-After. If you use Maintenance by WebFactory, tick its 503 box before you switch it on. If you use Under Construction or the free Minimal Coming Soon, use something else for downtime on a live site.
  • For a closure longer than two days, Google's guide prefers a working 200 home page explaining the situation over a site-wide 503. Keep your contact details and opening date on it.
  • Never redirect every URL to one maintenance page. Each URL should answer for itself with 503; a redirect tells Google the pages moved.
  • Leave robots.txt alone. Make sure your maintenance setup, and any server rule you add for it, doesn't catch robots.txt. The script below checks it.

A script that checks what your site sends while it's down

Turn maintenance mode on, then run this from any computer with Node.js 18 or later. It requests robots.txt, your home page, any paths you add, the first URLs in your sitemap and one made-up URL, then flags the patterns Google warns about.

check-downtime.mjs
// check-downtime.mjs: what does your site tell Google while it's down?
// Usage: node check-downtime.mjs https://www.example.com [/a-page /another-page ...]
// Node 18+. No dependencies. Run it while maintenance mode is on.
import { createHash } from 'node:crypto';
 
const site = new URL(process.argv[2] || 'https://www.example.com').origin;
const extra = process.argv.slice(3).map(p => new URL(p, site).href);
const UA = 'Mozilla/5.0 (compatible; downtime-check/1.0)';
 
async function get(url) {
  try {
    const res = await fetch(url, { redirect: 'manual', headers: { 'user-agent': UA } });
    const body = await res.text();
    return {
      url, status: res.status,
      retryAfter: res.headers.get('retry-after'),
      location: res.headers.get('location'),
      hash: createHash('sha1').update(body).digest('hex').slice(0, 10),
      body,
    };
  } catch (e) {
    return { url, status: 0, error: e.cause?.code || e.message };
  }
}
 
// Pages to test: the home page, any paths you pass, and the first sitemap URLs.
// (In maintenance mode the sitemap is often down too, so pass a few paths.)
const sitemap = await get(`${site}/sitemap.xml`);
const fromSitemap = sitemap.status === 200
  ? [...sitemap.body.matchAll(/<loc>\s*([^<\s]+)\s*<\/loc>/g)].map(m => m[1]).filter(u => !u.endsWith('.xml'))
  : [];
const urls = [...new Set([`${site}/`, ...extra, ...fromSitemap])].slice(0, Math.max(5, extra.length + 1));
// Add one URL that should never exist, to see what a missing page returns.
urls.push(`${site}/this-page-should-not-exist-${Date.now()}`);
 
const robots = await get(`${site}/robots.txt`);
const pages = [];
for (const u of urls) pages.push(await get(u));
 
const line = r => `${String(r.status || 'ERR').padEnd(4)} ${(r.retryAfter ? `Retry-After ${r.retryAfter}` : '').padEnd(20)} ${r.hash || r.error || ''}  ${r.url}${r.location ? ` -> ${r.location}` : ''}`;
console.log(line(robots));
pages.forEach(p => console.log(line(p)));
 
const problems = [];
if (robots.status >= 500 || robots.status === 429)
  problems.push(`robots.txt returns ${robots.status}. Google says a 503 on robots.txt blocks all crawling. Serve robots.txt normally.`);
const real = pages.slice(0, -1);
const ok = real.filter(p => p.status === 200);
if (ok.length >= 2 && new Set(ok.map(p => p.hash)).size === 1)
  problems.push(`${ok.length} different URLs return 200 with the same body. If that is a maintenance page, Google can index it or fold the pages together as duplicates. Return 503.`);
if (pages.at(-1).status === 200 && ok.length && pages.at(-1).hash === ok[0].hash)
  problems.push('A made-up URL returns the same 200 page as your home page: every URL is serving one page with 200. If the site is down, return 503.');
for (const p of real) {
  if (p.status === 503 && !p.retryAfter) problems.push(`${p.url} returns 503 without Retry-After. Add one (seconds or a date).`);
  if ([401, 403, 404, 410].includes(p.status)) problems.push(`${p.url} returns ${p.status}: Google treats it as gone and drops it from the index. Use 503 for downtime.`);
  if (p.status >= 300 && p.status < 400 && p.location) problems.push(`${p.url} redirects to ${p.location}. Redirecting every page to one maintenance URL hides the real pages; serve 503 at each URL instead.`);
}
console.log(problems.length ? `\nProblems:\n- ${problems.join('\n- ')}` : '\nNo downtime problems found.');

Run it with your domain and two or three real paths, because a site in maintenance mode often hides its sitemap too:

node check-downtime.mjs https://www.example.com /about /contact

The script never logs in, so it sees what Google sees. If you check in a browser too, log out first: most plugins show the real site to logged-in admins.

How we tested it: we ran it against a small local server set up five ways: a normal site, a 200 maintenance page on every URL (the Under Construction behavior), a correct 503 with Retry-After and robots.txt left alone, a 503 on everything including robots.txt with no Retry-After, and every URL redirected to one maintenance page. It passed the normal site and the correct 503, and flagged every problem in the other three. On our own live site it found no problems, as expected for a site that's up.

What we don't know yet

  • How quickly Google indexes a 200 maintenance page in practice, and how long the duplicate effect Mueller described lasts. Neither Google nor the report gives a timescale.
  • How plugin settings, caching plugins and hosts change the result. A page cache or CDN can store the maintenance page with whatever status it got, which is one more reason to run the check from outside.

For the related case of a site moving to a CDN, see Google's advice on 503 and 429 during a CDN migration.

Sources

Photo of Kiran Dasgupta

About the author

Kiran Dasgupta, Editor

Kiran runs Kihan Marketing, a web design, SEO and ads agency, and manages dozens of websites across real estate, home services and healthcare. He writes about SEO, AI search and paid ads news, and what it means for the people who run websites.