---
title: "WordPress MCP Security: Scopes, App Passwords, Read vs Write"
url: https://hostmy.blog/wordpress-mcp-security/
date: 2026-10-25
modified: 2026-10-25
lang: en
author: "Aditya Sharma"
description: "Connecting an AI to WordPress means giving software a login. The four layers that limit what it can do, and how to keep read and write access apart."
categories:
  - "RankReady"
image: https://hostmy.blog/wp-content/uploads/2026/10/hmb-card-2623-1024x538.jpg
word_count: 1488
---

# WordPress MCP Security: Scopes, App Passwords, Read vs Write

Connecting an AI to a WordPress site means giving software a login. Everything about WordPress MCP security follows from that. The AI can do what its account can do, and what the abilities you expose allow. Nothing about the AI's own cleverness changes it.

This post is the security view. It sets out the layers that decide what an AI can do, what to choose at each one, and how to keep read access and write access apart. It assumes you know what the pieces are, which [WordPress MCP: what the Abilities API lets an AI do](/wordpress-mcp/) explains. It is about limiting risk, not about building anything.

## The four layers

Four things sit between an AI client and your site's data. Each one can say no, and the safest setups choose a tight setting at all four.

| Layer | What it decides | Where it is set |
| ----- | --------------- | --------------- |
| The account | Which WordPress user the AI acts as, and so its role and capabilities | The Users screen |
| The credential | How that user is authenticated, and whether it can be revoked | The user's profile, as an application password |
| The server gate | Whether a request may reach the MCP server at all | The adapter's transport permission |
| The ability | Whether this one action is visible, and who may run it | The ability's own visibility and permission check |

The first two are about identity. The last two are about what is exposed. A weakness in one is covered by strength in another, and a loose setting at all four is how an AI ends up able to do far more than anyone intended.

## Layer one: the account

Create a dedicated user for the AI. Do not use your own login. A separate account shows in the user list, can be removed on its own, and can be given a role that fits the job. WordPress's [roles and capabilities documentation](https://wordpress.org/documentation/article/roles-and-capabilities/) describes the default roles. An Administrator has access to all administration features. An Editor can publish and manage posts, including other users' posts. An Author can publish and manage their own. A Contributor can write and manage their own posts but cannot publish them.

That last line is useful. If the AI only needs to create drafts, a Contributor account is a natural fit, because the role itself cannot publish. Whether an ability honours that depends on the ability checking the right capability, so test it. The principle holds either way. Pick the lowest role that does the job, and do not hand an AI an Administrator account because it is convenient.

## Layer two: the credential

WordPress's built-in way for software to authenticate is the application password. The [integration guide](https://make.wordpress.org/core/2020/11/05/application-passwords-integration-guide/) describes it. It arrived in WordPress 5.6. Each one belongs to a user, has a name and a record of when it was created and last used, and can be revoked from that user's profile. It is sent with HTTP Basic Auth over HTTPS, it is enabled by default only on HTTPS sites, and it cannot be used to log in at wp-login.php. Site owners can turn the feature off, or restrict it to certain users, using filters.

Two cautions apply. An application password acts with the full permissions of its user. The guide, published in 2020, says that finer-grained scoping was planned and not yet available, so check the current position before you rely on it, and assume the user's role is the limit. And treat the value like any password. Store it somewhere secure, and never in a file that is shared or committed. Give each tool its own, named so you know which to revoke.

## Layer three: the server gate

The adapter has a first gate in front of everything. The [transport permissions guide](https://github.com/WordPress/mcp-adapter/blob/trunk/docs/guides/transport-permissions.md) says that, if no callback is supplied, the server checks that the user is logged in. A custom callback can be supplied, and for HTTP it receives the request, so it can check a header. Two details are worth knowing. If the callback throws an exception, the adapter falls back to the logged-in check. And the gate is only the first layer: each ability still applies its own permission check after it.

The practical point is that being logged in is a weak gate on its own. Any valid user passes it. Everything then depends on the account's role and on what each ability allows, which is why the first and fourth layers matter more.

## Layer four: the abilities

The adapter's README says abilities are private by default, and that an ability has to be marked public before an MCP client can see it. WordPress core is separate: exposing an ability over the REST API is opt-in, and needs an authenticated user. Take the opposite approach from convenience. Expose only the abilities the job needs, and review the list whenever a plugin is added, because plugins can register abilities of their own.

For each ability, ask what it does, what its permission check requires, and what the worst result of running it would be. An ability that reads a post list is low risk. One that changes or deletes content, or that can run code, is not, and it deserves a deliberate decision.

## Read first, then write

| Kind of ability | Examples | Starting position |
| --------------- | -------- | ----------------- |
| Read | List posts, read a post, list categories | Fine to start with |
| Create | Make a draft | Allow with a low-privilege account |
| Change | Edit a post, update settings | Allow narrowly, and for a defined task |
| Publish or delete | Publish, trash, remove | Keep a person in the loop |
| Run code or commands | Anything that executes arbitrary code | Avoid, or isolate completely |

Start with read-only access and see what you actually need. Add drafting next. Keep publishing, deletion and anything that executes code out of reach unless there is a clear reason, and keep a person making the final call. On this site, publishing a post is a person's decision.

## Untrusted content and the AI that reads it

One risk is not about accounts at all. An AI reads text, and text can contain instructions. A comment, a form submission, an email or a page it has fetched can all include words aimed at the AI. If the same session can also change your site, an instruction hidden in that text may be followed. The WebMCP specification has its own section on prompt injection, and notes that natural language is inherently ambiguous and hard to sanitise.

The defence is separation. Do not give a session that reads untrusted content the ability to change or publish anything. Use read-only access for sessions that handle comments or submissions, and keep write abilities for sessions that only see your own material.

## Review and revoke

Security is not a one-time setup. Check which abilities are exposed, which users have application passwords, and when each was last used. Revoke what you no longer need, and remove the dedicated user when the project ends. An activity log plugin gives you a record of who did what, which helps when something looks wrong. Before you grant any write access, make sure you have a backup you have actually restored, as in [the WordPress backup that did not restore](/wordpress-backup/). Read [WordPress security without a security plugin that fights your host](/wordpress-security/) for the wider picture.

`1. Create a dedicated user for the AI, with the lowest role that works.
2. Give it one named application password, over HTTPS.
3. Expose only the abilities the job needs, and start read-only.
4. Test as that user before relying on it.
5. Keep publish, delete and code execution out of reach.
6. Use read-only sessions for anything that reads untrusted text.
7. Review monthly, and revoke what you no longer use.`

The adapter's guide describes a way to test as a given user from the command line, using the serve command with a user and server option. It is the safest way to see what an account can reach before you connect a client.

## What this post does not cover

It does not cover writing abilities, which is a developer task. It also does not cover WebMCP, which is a different mechanism that runs in the browser, explained in [what WebMCP is, and whether a WordPress blog needs it](/what-is-webmcp/). WordPress MCP acts on the site from outside. WebMCP acts on a page from inside the visitor's browser.

Last checked in October 2026 against the WordPress Application Passwords guide and the MCP Adapter documentation. Both are changing quickly, so check the current versions before you rely on a detail.

## Where RankReady fits

RankReady's own WebMCP manifest takes the cautious route by design. It is off until you switch it on, every call is read-only, and it returns only published, public content. Comments, users, media, installed plugins and settings are off by default, and nothing in it can write. It does not need the MCP adapter at all, so it adds nothing to the attack surface described above. The free [AI Readiness Checker](https://hostmy.blog/plugins/rankready/ai-readiness-checker/) shows what your public site exposes today.

If an AI connected to your site tomorrow, which user would it log in as, and what is the worst thing that account could do?