Severity: Major · Fix time: 5–15 min · Skill level: Intermediate

Updating Failed (also displayed as “Publishing Failed”) is a Gutenberg block editor error that appears when WordPress cannot save or publish a post or page. The most common cause is a blocked or misconfigured REST API — Gutenberg depends on the REST API to communicate with the server, and anything that interrupts that connection produces this error.

When this error appears, your content is not lost. WordPress autosaves drafts locally in the browser, so your work is preserved. The problem is on the server side: something is preventing Gutenberg’s save request from completing. Understanding what is blocking the REST API gets you to a resolution quickly.

Need a quick map of every WordPress error? See our 70+ WordPress Errors Guide → for a categorized reference of every common WordPress issue.

[Image: Screenshot of the Gutenberg editor showing the “Updating Failed” and “Publishing Failed” error banners with the site health REST API warning]

How Updating Failed Works

Gutenberg communicates with WordPress entirely through the REST API. When you click “Publish” or “Update,” the block editor fires an authenticated REST API request to the /wp-json/wp/v2/posts/ endpoint. If that request is blocked, returns an unexpected response, or times out, Gutenberg surfaces the “Updating Failed” or “Publishing Failed” error.

Several conditions can interrupt this request:

  • Security plugins or firewalls — Wordfence, iThemes Security, and server-level WAFs like Cloudflare’s firewall can block REST API requests they flag as suspicious. This is the single most common cause in our experience.
  • Permalink misconfiguration — If your WordPress Address (URL) and Site Address (URL) under Settings → General do not match the actual domain where WordPress is installed, REST API requests are routed to the wrong endpoint and fail.
  • Plugins disabling the REST API — Some older security or performance plugins include an option to “disable the REST API for non-logged-in users.” This setting can block Gutenberg even when you are logged in, if the implementation is imprecise.
  • PHP memory limit — If the PHP process runs out of memory during the save request, the REST endpoint returns an error instead of a success response. The block editor translates this as “Updating Failed.”
  • Incorrect SSL configuration — A site running on HTTP while WordPress expects HTTPS (or vice versa) can cause REST API requests to be redirected in a way that breaks authentication.

Check This First — 2-Minute Diagnostic

  1. Check Tools → Site Health — Navigate to Tools → Site Health → Status. Look for any message referencing the REST API. A red flag reading “The REST API encountered an unexpected result” identifies the problem immediately.
  2. Verify WordPress Address and Site Address — Go to Settings → General. Confirm that both URL fields are identical and match the URL you use to visit the site.
  3. Test in an incognito window — Open an incognito browser window and try to edit a draft post. Browser extensions, especially ad blockers, occasionally interfere with REST API requests.
  4. Disable all plugins temporarily — If the error disappears after bulk-deactivating plugins, a specific plugin is the culprit. Reactivate one at a time until the error returns.
  5. Check your PHP error log — A “Allowed memory size exhausted” message alongside the timestamp of your failed save points to a memory limit cause.

Purpose & Benefits

1. Protecting Your Content from Silent Data Loss

When the Gutenberg save request fails, content edits are not saved to the database. If you navigate away from the page after seeing “Updating Failed,” recent edits may be lost. Understanding the error means keeping the tab open while troubleshooting and not reloading the page until the issue is resolved. Fixing the root cause prevents future content loss during active editorial sessions.

2. Diagnosing the Root Cause Prevents Recurrence

A “Updating Failed” error that gets fixed by simply disabling and re-enabling a caching plugin will come back the next time that plugin updates or its settings change. Identifying whether the block is coming from a firewall rule, a misconfigured plugin, or a permalink issue allows a permanent fix rather than a workaround that disappears on the next update cycle.

3. REST API Blocks Have Broader Consequences

The WordPress REST API is used not just by Gutenberg, but by WooCommerce, Jetpack, and dozens of other plugins and integrations. A REST API block causing “Updating Failed” in the editor is often also silently breaking features elsewhere on the site. Resolving the block fully — rather than working around it by switching to the Classic Editor — protects every system that depends on REST API access.

Examples

1. Cloudflare WAF Rule Blocking POST Requests

A client running a managed WordPress site experienced “Updating Failed” consistently after migrating to a new server behind Cloudflare. Site Health showed the REST API returning a 403 Forbidden response. The culprit was a Cloudflare WAF rule set to block all POST requests matching /wp-json/*. Adding a firewall rule exception for authenticated POST requests to /wp-json/wp/v2/ resolved the error within minutes.

# In Cloudflare: create a bypass rule for authenticated REST API calls
# Rule condition: (http.request.uri.path contains "/wp-json/wp/v2/")
# Action: Bypass WAF
# This allows Gutenberg to save while keeping general WAF protection active

After applying the exception, publishing and updating worked immediately with the broader WAF protection remaining in place for non-admin traffic.

2. Permalink Flush After HTTPS Migration

A site had recently moved from HTTP to HTTPS. The WordPress Address was updated to https:// correctly, but an old redirect rule in .htaccess was redirecting all /wp-json/ requests to the non-SSL URL before WordPress could process them. The REST API health check showed a 301 response instead of 200.

// Enforce correct site URL in wp-config.php to prevent REST redirect loops
define('WP_HOME', 'https://example.com');
define('WP_SITEURL', 'https://example.com');
// Then visit Settings > Permalinks and click "Save Changes" to flush rewrite rules

Removing the old HTTP redirect rule and confirming the HTTPS values in wp-config.php resolved the REST routing issue. A visit to Settings → Permalinks → Save Changes (without changing anything) regenerates rewrite rules and resolves many REST API routing problems after migrations.

3. Security Plugin Blocking Admin REST Requests

A site running iThemes Security had “Disable REST API” enabled, blocking unauthenticated nonce verification requests that Gutenberg makes during editor page load — before the login session is fully established in the request context. Switching the setting to allow logged-in user access resolved the publishing failure without removing security restrictions for public traffic.

Common Mistakes to Avoid

  • Switching to Classic Editor as a permanent fix — Classic Editor bypasses the REST API entirely, which is why publishing works again. But the REST API remains broken for WooCommerce, Jetpack, and other integrations. Fix the root cause rather than hiding it.
  • Ignoring the Site Health REST API warning — Many sites have a REST API error logged in Site Health for months, unnoticed because editors switched to Classic Editor out of habit. Run a Site Health check whenever this error appears.
  • Disabling security features globally — Turning off the entire security plugin is fine for a 5-minute test. Always re-enable it and find the specific rule or setting causing the conflict. Leaving security disabled is never the solution.
  • Not flushing permalinks after migrations — A visit to Settings → Permalinks → Save Changes regenerates the rewrite rules. This resolves a significant number of REST API routing failures after domain changes or HTTPS migrations and takes under 60 seconds.
  • Overlooking PHP memory limits — A low memory limit produces a REST API 500 error that looks identical to a security block. Check both causes when Site Health shows the REST API failing.

Best Practices

1. Check Site Health Before Anything Else

WordPress’s built-in REST API health check at Tools → Site Health → Status takes 30 seconds and immediately indicates whether the REST API is responding normally. If it shows a warning, the diagnostic is largely done — the message often names the cause. Always start here before disabling plugins or editing configuration files.

2. Increase PHP Memory If the REST API Returns 500 Errors

If Site Health shows the REST API returning a 500 Internal Server Error, a PHP memory limit is a likely cause. Add this to wp-config.php above the “That’s all, stop editing!” line:

// Increase PHP memory limit to resolve REST API 500 errors causing Gutenberg failures
define( 'WP_MEMORY_LIMIT', '256M' );

After saving, test the REST API via Site Health again. If the 500 error clears, the memory limit was the cause.

3. Flush Permalinks After Any Migration or Domain Change

After moving to a new domain, switching from HTTP to HTTPS, or migrating servers, always visit Settings → Permalinks and click “Save Changes.” This regenerates the rewrite rules that govern REST API request routing and resolves a large share of post-migration “Updating Failed” errors immediately.

4. Isolate Conflicting Plugins Systematically

Bulk deactivate all plugins, then reactivate one at a time — security plugins and caching plugins first. Test the Gutenberg editor after each activation. This takes 10–15 minutes but gives a definitive answer about which plugin caused the conflict, so you can configure it correctly or find an alternative rather than guessing.

5. Enable WP_DEBUG to Catch PHP Errors in the REST Response

// Temporary debug setup — add to wp-config.php to log REST API errors
define( 'WP_DEBUG', true );
define( 'WP_DEBUG_LOG', true );
define( 'WP_DEBUG_DISPLAY', false );

Check wp-content/debug.log after a failed publish attempt. PHP errors or memory exhaustion messages there point directly to the next fix step. Remove these lines once the issue is resolved — do not leave debug mode active on a live production site.

Frequently Asked Questions

What causes “Updating Failed” in Gutenberg most often?

A blocked REST API — usually caused by a security plugin, WAF rule, or Cloudflare firewall blocking POST requests to /wp-json/. The second most common cause is a permalink mismatch after a site migration. Run Tools → Site Health first; it identifies the cause without guesswork in most cases.

How do I fix “Updating Failed” when I can’t access wp-admin?

This error does not lock you out of wp-admin — you can still log in and navigate your dashboard. If you cannot log in at all, you are dealing with a separate issue like the White Screen of Death or a database connection error. With this specific error, you remain in the editor and can navigate — you simply cannot save the current post.

Can “Updating Failed” hurt my SEO?

Not directly. Existing published content remains intact and indexed. The indirect risk is if the error persists for days — you cannot publish new content or update existing pages, stalling your SEO and content output. Resolve it promptly.

Does switching to the Classic Editor permanently fix this?

No. Classic Editor bypasses Gutenberg’s REST API dependency, so the publishing error disappears from the editor. But the REST API remains broken for WooCommerce, Jetpack, and other integrations. Treat Classic Editor as a temporary workaround, not a permanent resolution.

Why does “Updating Failed” happen on some posts but not others?

A post-specific failure usually points to a plugin or block type that triggers a memory limit or timeout during the save request for that particular content. Try removing content blocks one at a time to identify the trigger, or check the PHP error log during a failed save on the problem post.

Related Glossary Terms

How CyberOptik Can Help

Still broken? Our team fixes WordPress errors like this in under 30 minutes for maintenance clients. “Updating Failed” errors often point to security or caching plugin conflicts that require careful configuration rather than simply disabling the offending plugin — getting that configuration right prevents the error from returning with the next update. Our WordPress maintenance services cover plugin conflict resolution, REST API diagnostics, and ongoing update management so your editorial team can publish without interruption. Contact us to discuss your site or review what our maintenance plans include.