Skip to content
Back to search

mcp-wordpress-remote

A Model Context Protocol (MCP) server for seamless WordPress integration

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Automattic/mcp-wordpress-remote with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Automattic/mcp-wordpress-remote'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/automattic--mcp-wordpress-remote/badge.svg)](/listings/automattic--mcp-wordpress-remote)

HTML

<a href="/listings/automattic--mcp-wordpress-remote"><img src="/api/listings/automattic--mcp-wordpress-remote/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Installation

npm install @automattic/mcp-wordpress-remote

Configuration

Add to your MCP client configuration (e.g., Claude Desktop's `claude_desktop_config.json`):

{
  "mcpServers": {
    "wordpress": {
      "command": "npx",
      "args": ["-y", "@automattic/mcp-wordpress-remote"],
      "env": {
        "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server"
      }
    }
  }
}

Custom Headers

You can add custom headers to all API requests using the `CUSTOM_HEADERS` environment variable. This is useful for API keys, custom authentication, or other header requirements.

JSON Format (Recommended):

{
  "mcpServers": {
    "wordpress": {
      "command": "npx",
      "args": ["-y", "@automattic/mcp-wordpress-remote"],
      "env": {
        "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
        "CUSTOM_HEADERS": "{\"X-MCP-API-Key\": \"*Ibo7tweixlbfuwaiufxgakjyefctwajcetb*\", \"X-Custom-Header\": \"value\"}"
      }
    }
  }
}

Comma-Separated Format:

{
  "mcpServers": {
    "wordpress": {
      "command": "npx",
      "args": ["-y", "@automattic/mcp-wordpress-remote"],
      "env": {
        "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
        "CUSTOM_HEADERS": "X-MCP-API-Key:IOskncfyes78U8on3q7ry43o487tybrc,X-Custom-Header:value"
      }
    }
  }
}

Command Line Usage:

CUSTOM_HEADERS='{"X-MCP-API-Key": "wc_mcp_FaQduhQcW0mfVaZgP3yaaqDuXaZ3mw7j"}' \
WP_API_URL="https://your-site.com/wp-json/mcp/mcp-adapter-default-server" \
npx @automattic/mcp-wordpress-remote

Custom headers are included in:

- All WordPress API requests - OAuth discovery requests - OAuth token exchange requests - OAuth client registration requests

First Run

1. **Start your MCP client** (Claude Desktop, etc.) 2. **Choose authentication method** based on your preference: - **OAuth 2.0** (default): Browser opens automatically for authorization - **JWT Token**: Set `JWT_TOKEN` environment variable - **Application Password**: Set `WP_API_USERNAME` and `WP_API_PASSWORD` 3. **Start using WordPress features** in your AI assistant

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 537 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # MCP WordPress Remote
  2. **A stdio-to-HTTP pass-through proxy for WordPress MCP servers**
  3. Connect AI assistants like Claude Desktop to your WordPress sites with multiple authentication methods including OAuth 2.0, JWT tokens, and application passwords.
  4. ## Features
  5. - **MCP OAuth Client** - Authorization-code PKCE, validated discovery, issuer-bound credentials, and coordinated renewal
  6. - **OAuth 2.1 with PKCE** - Secure authorization code flow with PKCE (RFC 7636)
  7. - **Resource Indicators** - RFC 8707 compliance for token audience binding
  8. - **Dynamic Client Registration** - RFC 7591 support for automatic client registration
  9. - **Protected Resource Metadata Discovery** - RFC 9728 for automatic endpoint discovery
  10. - **Multiple Authentication Methods** - OAuth 2.1, JWT tokens, and WordPress application passwords
  11. - **Persistent Token Storage** - OAuth tokens stored securely with automatic validation
  12. - **Multi-instance Coordination** - Lockfiles prevent authentication conflicts
  13. - **Automatic Token Management** - Handles validation, refresh, and cleanup
  14. - **Enhanced Error Handling** - Detailed error messages with proper categorization
  15. - **Comprehensive Logging** - Structured logging with categories and levels
  16. - **Complete MCP Support** - Tools, resources, prompts, and more
  17. ## When to use this proxy
  18. If your MCP client supports the Streamable HTTP transport and can authenticate to your site, connect it to the MCP Adapter endpoint directly. You don't need this proxy. For example, in Claude Code (`.mcp.json`), using an application password:
  19. ```json
  20. {
  21. "mcpServers": {
  22. "wordpress": {
  23. "type": "http",
  24. "url": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
  25. "headers": {
  26. "Authorization": "Basic <base64 of username:application-password>"
  27. }
  28. }
  29. }
  30. }
  31. ```
  32. Other clients use their own config format. Check your client's documentation for remote or HTTP MCP servers.
  33. Use the proxy when one of these applies:
  34. 1. **Your client only supports stdio.** It can launch a local command but cannot connect to an HTTP MCP server.
  35. 2. **Your client can't authenticate the way your site requires.** The proxy can send application passwords, JWT tokens, WooCommerce keys, or [custom headers](#custom-headers), and it can run the [OAuth flow](#authentication-methods) and store tokens for clients that can't.
  36. 3. **Your traffic must go through a proxy.** Set `SOCKS_PROXY`, `HTTPS_PROXY`, `ALL_PROXY` or `HTTP_PROXY` to route requests through it. On macOS, set `USE_SYSTEM_PROXY=true` to use the system PAC file or SOCKS proxy instead.
  37. 4. **Your site is slow or unreliable.** `WP_API_TIMEOUT_MS` and `WP_API_INIT_TIMEOUT_MS` set the timeouts, and a failed initialize returns a degraded response instead of a broken connection (see [Forwarding behavior](#forwarding-behavior)).
  38. 5. **You need a local record of the connection.** `LOG_FILE` with `LOG_LEVEL=3` logs each forwarded method plus connection and authentication events (see [Log Analysis](#log-analysis)).
  39. 6. **You are building a packaged integration.** Tool-call hooks from the `/lib` bundle can send extra requests over the proxy's authenticated connection, for example for usage telemetry.
  40. ## Quick Start
  41. ### Installation
  42. ```bash
  43. npm install @automattic/mcp-wordpress-remote
  44. ```
  45. ### Configuration
  46. Add to your MCP client configuration (e.g., Claude Desktop's `claude_desktop_config.json`):
  47. ```json
  48. {
  49. "mcpServers": {
  50. "wordpress": {
  51. "command": "npx",
  52. "args": ["-y", "@automattic/mcp-wordpress-remote"],
  53. "env": {
  54. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server"
  55. }
  56. }
  57. }
  58. }
  59. ```
  60. ### Custom Headers
  61. You can add custom headers to all API requests using the `CUSTOM_HEADERS` environment variable. This is useful for API keys, custom authentication, or other header requirements.
  62. #### JSON Format (Recommended):
  63. ```json
  64. {
  65. "mcpServers": {
  66. "wordpress": {
  67. "command": "npx",
  68. "args": ["-y", "@automattic/mcp-wordpress-remote"],
  69. "env": {
  70. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
  71. "CUSTOM_HEADERS": "{\"X-MCP-API-Key\": \"*Ibo7tweixlbfuwaiufxgakjyefctwajcetb*\", \"X-Custom-Header\": \"value\"}"
  72. }
  73. }
  74. }
  75. }
  76. ```
  77. #### Comma-Separated Format:
  78. ```json
  79. {
  80. "mcpServers": {
  81. "wordpress": {
  82. "command": "npx",
  83. "args": ["-y", "@automattic/mcp-wordpress-remote"],
  84. "env": {
  85. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
  86. "CUSTOM_HEADERS": "X-MCP-API-Key:IOskncfyes78U8on3q7ry43o487tybrc,X-Custom-Header:value"
  87. }
  88. }
  89. }
  90. }
  91. ```
  92. #### Command Line Usage:
  93. ```bash
  94. CUSTOM_HEADERS='{"X-MCP-API-Key": "wc_mcp_FaQduhQcW0mfVaZgP3yaaqDuXaZ3mw7j"}' \
  95. WP_API_URL="https://your-site.com/wp-json/mcp/mcp-adapter-default-server" \
  96. npx @automattic/mcp-wordpress-remote
  97. ```
  98. Custom headers are included in:
  99. - All WordPress API requests
  100. - OAuth discovery requests
  101. - OAuth token exchange requests
  102. - OAuth client registration requests
  103. ### First Run
  104. 1. **Start your MCP client** (Claude Desktop, etc.)
  105. 2. **Choose authentication method** based on your preference:
  106. - **OAuth 2.0**: Enable `OAUTH_ENABLED=true` to open the browser for authorization
  107. - **JWT Token**: Set `JWT_TOKEN` environment variable
  108. - **Application Password**: Set `WP_API_USERNAME` and `WP_API_PASSWORD`
  109. 3. **Start using WordPress features** in your AI assistant
  110. ## WordPress MCP Plugin
  111. Install the [MCP Adapter](https://github.com/WordPress/mcp-adapter) plugin on your WordPress site. Once active, it registers a default MCP server at `/wp-json/mcp/mcp-adapter-default-server` — set `WP_API_URL` to that full URL (examples throughout this README show the pattern). To target a custom server id or namespace, pass the full URL of that server instead.
  112. ### Forwarding behavior
  113. The proxy forwards the MCP client's messages to the configured endpoint and returns the server's messages. It does not send its own initialization probe, select an MCP version, or register a fixed set of methods. The client and server own version negotiation, capabilities, and result validation. Requests, notifications, server requests, IDs, and metadata travel through the bridge; JSON and SSE responses are supported.
  114. For initialization-based MCP connections, the server's selected version and session ID are used in subsequent HTTP headers. Requests carrying `io.modelcontextprotocol/protocolVersion` in `params._meta` use that version directly and do not require a proxy-generated handshake. This removes the proxy's version allowlist; it does not translate between protocol revisions or establish full compliance with every newer transport feature.
  115. Existing authentication, custom headers, timeout, logging, token-storage, and system-proxy settings remain available. A bare-domain `WP_API_URL` now resolves to `/?rest_route=/mcp/mcp-adapter-default-server`. Full endpoint URLs remain configurable. The archived `wordpress-mcp` plugin's method-only request format and automatic transport fallback have been removed.
  116. If the upstream connection fails during initialization, the proxy retains its degraded response with `experimental.connectionFailed` and no usable capabilities, using the client's offered version. Follow-up requests are rejected locally. Server-generated JSON-RPC errors are forwarded rather than converted to a successful handshake. The proxy does not silently reinitialize or retry failed client requests.
  117. Tool-call hooks and `wpRequest` from the `/lib` bundle share the live authenticated connection when the proxy is running. Hook responses remain internal and hook failures cannot change the client response. Standalone `wpRequest` retains its result-returning interface and optional session recovery; both its existing argument shapes are encoded as standard JSON-RPC.
  118. ## Authentication Methods
  119. ### 1. OAuth 2.1 (Recommended)
  120. OAuth 2.1 uses a public native client with PKCE S256, validated MCP discovery, and coordinated token renewal. See [OAuth client behavior](Docs/authentication.md) for the supported profile, migration behavior, and optional features.
  121. #### **For Self-Hosted WordPress Sites:**
  122. ```json
  123. {
  124. "mcpServers": {
  125. "wordpress": {
  126. "command": "npx",
  127. "args": ["-y", "@automattic/mcp-wordpress-remote"],
  128. "env": {
  129. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
  130. "OAUTH_ENABLED": "true"
  131. }
  132. }
  133. }
  134. }
  135. ```
  136. **MCP Authorization Specification Features:**
  137. - **OAuth 2.1 authorization code flow** with PKCE (RFC 7636)
  138. - **Resource Indicators** (RFC 8707) for token audience binding
  139. - **Dynamic Client Registration** (RFC 7591) when supported
  140. - **Protected Resource Metadata Discovery** (RFC 9728)
  141. - **Authorization Server Metadata Discovery** (RFC 8414)
  142. **Benefits:**
  143. - Public native-client authorization following the MCP 2026-07-28 authorization requirements
  144. - Enhanced security with PKCE protection
  145. - Shared browser authorization and refresh-token renewal when supported
  146. - Tokens stored securely with automatic validation
  147. - Automatic endpoint discovery
  148. - No need to manage passwords
  149. - Automatic expiration handling
  150. ### 2. JWT Token Authentication
  151. For server-to-server authentication or when OAuth is not available.
  152. ```json
  153. {
  154. "mcpServers": {
  155. "wordpress": {
  156. "command": "npx",
  157. "args": ["-y", "@automattic/mcp-wordpress-remote"],
  158. "env": {
  159. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
  160. "JWT_TOKEN": "your-jwt-token-here"
  161. }
  162. }
  163. }
  164. }
  165. ```
  166. ### 3. WordPress Application Passwords (Legacy)
  167. Uses WordPress username and application password for basic authentication.
  168. ```json
  169. {
  170. "mcpServers": {
  171. "wordpress": {
  172. "command": "npx",
  173. "args": ["-y", "@automattic/mcp-wordpress-remote"],
  174. "env": {
  175. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
  176. "WP_API_USERNAME": "your-username",
  177. "WP_API_PASSWORD": "your-application-password",
  178. "OAUTH_ENABLED": "false"
  179. }
  180. }
  181. }
  182. }
  183. ```
  184. To create an application password:
  185. 1. Go to your WordPress admin dashboard
  186. 2. Navigate to Users > Profile
  187. 3. Scroll down to "Application Passwords"
  188. 4. Create a new application password for MCP access
  189. ## Advanced Configuration
  190. ### Custom OAuth Settings
  191. ```json
  192. {
  193. "mcpServers": {
  194. "wordpress": {
  195. "command": "npx",
  196. "args": ["-y", "@automattic/mcp-wordpress-remote"],
  197. "env": {
  198. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
  199. "OAUTH_CALLBACK_PORT": "7665",
  200. "OAUTH_HOST": "127.0.0.1",
  201. "WP_OAUTH_CLIENT_ID": "your-custom-client-id"
  202. }
  203. }
  204. }
  205. }
  206. ```
  207. ### WooCommerce Integration
  208. For WooCommerce-specific tools and reports:
  209. ```json
  210. {
  211. "mcpServers": {
  212. "wordpress": {
  213. "command": "npx",
  214. "args": ["-y", "@automattic/mcp-wordpress-remote"],
  215. "env": {
  216. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server",
  217. "WOO_CUSTOMER_KEY": "ck_your-consumer-key",
  218. "WOO_CUSTOMER_SECRET": "cs_your-consumer-secret"
  219. }
  220. }
  221. }
  222. }
  223. ```
  224. ### Environment Variables
  225. | Variable | Description | Default | Required |
  226. | ----------------------------- | ------------------------------------------------ | -------------------- | --------------------- |
  227. | `WP_API_URL` | WordPress site URL including the MCP endpoint path (e.g. `…/wp-json/mcp/mcp-adapter-default-server`). A bare domain resolves to the MCP Adapter default server. | - | ✅ |
  228. | `OAUTH_ENABLED` | Enable OAuth authentication | `false` | - |
  229. | `OAUTH_CALLBACK_PORT` | OAuth callback port | `7665` | - |
  230. | `OAUTH_HOST` | OAuth callback hostname | `127.0.0.1` | - |
  231. | `OAUTH_TIMEOUT_MS` | Time to wait for the browser OAuth login (ms) | `30000` | - |
  232. | `WP_OAUTH_CLIENT_ID` | Custom OAuth client ID | - | - |
  233. | **OAuth Endpoints** | | | |
  234. | `OAUTH_AUTHORIZE_ENDPOINT` | OAuth authorization endpoint | - | ✅ (for custom OAuth) |
  235. | `OAUTH_TOKEN_ENDPOINT` | OAuth token endpoint | - | ✅ (for custom OAuth) |
  236. | `OAUTH_AUTHENTICATE_ENDPOINT` | OAuth authenticate endpoint | - | - |
  237. | **MCP OAuth 2.1 Settings** | | | |
  238. | `OAUTH_FLOW_TYPE` | OAuth flow type (authorization_code or implicit) | `authorization_code` | - |
  239. | `OAUTH_USE_PKCE` | Use PKCE (required for OAuth 2.1) | `true` | - |
  240. | `OAUTH_DYNAMIC_REGISTRATION` | Enable dynamic client registration | `true` | - |
  241. | `OAUTH_RESOURCE_INDICATOR` | Use resource indicators (RFC 8707) | `true` | - |
  242. | **Configuration** | | | |
  243. | `WP_MCP_CONFIG_DIR` | Config directory override | `~/.mcp-auth` | - |
  244. | `LOG_FILE` | Log file path | - | - |
  245. | `LOG_LEVEL` | Log level (0-3) | `2` | - |
  246. | `LOG_TO_STDERR` | Mirror all log levels to stderr (errors always are) | `false` | - |
  247. | `WP_API_TIMEOUT_MS` | Request timeout for tool calls (ms) | `120000` | - |
  248. | `WP_API_INIT_TIMEOUT_MS` | Initialize timeout (ms), after OAuth login | `25000` | - |
  249. | `PROXY_PAC_TIMEOUT_MS` | Timeout for PAC download and resolver setup (ms) | `5000` | - |
  250. | **Network Proxy** | | | |
  251. | `SOCKS_PROXY` | SOCKS proxy URL (`socks5h://` resolves DNS on the proxy) | - | - |
  252. | `HTTPS_PROXY` | HTTP(S) proxy URL, used when `SOCKS_PROXY` is unset | - | - |
  253. | `ALL_PROXY` | Proxy URL, used when the above are unset | - | - |
  254. | `HTTP_PROXY` | Proxy URL, used when the above are unset | - | - |
  255. | `NO_PROXY` | Comma-separated hosts that bypass the proxy | - | - |
  256. | `USE_SYSTEM_PROXY` | Also detect the macOS system PAC file or SOCKS proxy when no proxy URL is set | `false` | - |
  257. | **TLS / Certificates** | | | |
  258. | `NODE_EXTRA_CA_CERTS` | Path to an extra CA file to trust (mkcert/corporate CA) | - | - |
  259. | `NODE_USE_SYSTEM_CA` | Trust the OS certificate store (Node 22.15+) | - | - |
  260. | **Legacy Authentication** | | | |
  261. | `JWT_TOKEN` | JWT token for authentication | - | - |
  262. | `WP_API_USERNAME` | WordPress username (legacy) | - | - |
  263. | `WP_API_PASSWORD` | WordPress app password (legacy) | - | - |
  264. | `WOO_CUSTOMER_KEY` | WooCommerce consumer key | - | - |
  265. | `WOO_CUSTOMER_SECRET` | WooCommerce consumer secret | - | - |
  266. ### Disable OAuth
  267. To use only JWT or Basic Auth:
  268. ```json
  269. {
  270. "env": {
  271. "OAUTH_ENABLED": "false",
  272. "JWT_TOKEN": "your-jwt-token"
  273. }
  274. }
  275. ```
  276. ## Development Mode
  277. For development and testing, you can use the local repository:
  278. ### Setup
  279. 1. **Clone the repository:**
  280. ```bash
  281. git clone https://github.com/Automattic/mcp-wordpress-remote.git
  282. cd mcp-wordpress-remote
  283. ```
  284. 2. **Install dependencies:**
  285. ```bash
  286. npm install
  287. ```
  288. 3. **Build the project:**
  289. ```bash
  290. npm run build
  291. ```
  292. ### Configuration
  293. Configure your MCP client to use the local version:
  294. ```json
  295. {
  296. "mcpServers": {
  297. "wordpress": {
  298. "command": "node",
  299. "args": ["/path/to/your/mcp-wordpress-remote/dist/proxy.js"],
  300. "env": {
  301. "WP_API_URL": "https://your-wordpress-site.com/wp-json/mcp/mcp-adapter-default-server"
  302. }
  303. }
  304. }
  305. }
  306. ```
  307. ### Development Workflow
  308. - **Watch mode:** `npm run build:watch` - Automatically rebuilds on file changes
  309. - **Testing:** `npm test` - Run the test suite
  310. - **Type checking:** `npm run check` - Run TypeScript and Prettier checks
  311. ## Token Management
  312. ### OAuth Token Storage
  313. Tokens are automatically stored in:
  314. ```
  315. ~/.mcp-auth/wordpress-remote-{version}/
  316. ```
  317. ### Manual Management
  318. ```bash
  319. # View stored tokens
  320. ls -la ~/.mcp-auth/wordpress-remote-*/
  321. # Clear all tokens (forces re-authentication)
  322. rm -rf ~/.mcp-auth/wordpress-remote-*/
  323. # Clear tokens for specific version
  324. rm -rf ~/.mcp-auth/wordpress-remote-0.2.1/
  325. ```
  326. ### Token Security
  327. - **Secure file permissions** (600) on all token files
  328. - **Automatic token validation** before each request
  329. - **Expired token cleanup** during startup
  330. - **Version isolation** - each version stores tokens separately
  331. ## Multi-Instance Support
  332. The proxy automatically coordinates between multiple instances:
  333. - **Lockfiles** prevent simultaneous OAuth flows
  334. - **Process coordination** ensures only one authentication at a time
  335. - **Graceful waiting** when another instance is authenticating
  336. - **Automatic cleanup** of stale locks
  337. If you see "waiting for other instance" messages, this is normal behavior.
  338. ## Troubleshooting
  339. ### Authentication Issues
  340. **OAuth browser doesn't open:**
  341. - Check if port 3000 is available
  342. - Try a different port with `OAUTH_CALLBACK_PORT`
  343. - Manually open the URL shown in logs
  344. **OAuth authorization fails:**
  345. - Verify WordPress site has MCP plugin installed and enabled
  346. - Check WordPress admin user permissions
  347. - Try clearing tokens and re-authenticating
  348. **JWT authentication fails:**
  349. - Verify JWT token is valid and not expired
  350. - Check token format and encoding
  351. - Ensure WordPress site supports JWT authentication
  352. **Basic Auth fails:**
  353. - Verify username and application password
  354. - Check application password is active
  355. - Ensure user has sufficient permissions
  356. ### Connection Issues
  357. **API endpoint not found:**
  358. - Verify the [MCP Adapter](https://github.com/WordPress/mcp-adapter) plugin is installed and active
  359. - Confirm `WP_API_URL` points at the server route (e.g. `…/wp-json/mcp/mcp-adapter-default-server`)
  360. **Permission denied:**
  361. - Check user permissions in WordPress
  362. - Verify authentication credentials
  363. - Review WordPress user roles
  364. ### Port Conflicts
  365. If port 3000 is already in use:
  366. ```json
  367. {
  368. "env": {
  369. "OAUTH_CALLBACK_PORT": "8080"
  370. }
  371. }
  372. ```
  373. ### Multi-instance Messages
  374. "Waiting for other instance" messages are normal when multiple MCP clients start simultaneously. The system coordinates authentication to prevent conflicts.
  375. ### Log Analysis
  376. Enable detailed logging:
  377. ```json
  378. {
  379. "env": {
  380. "LOG_LEVEL": "3",
  381. "LOG_FILE": "/path/to/logfile.log"
  382. }
  383. }
  384. ```
  385. Log levels:
  386. - `0` - Errors only
  387. - `1` - Warnings and errors
  388. - `2` - Info, warnings, and errors (default)
  389. - `3` - Debug, info, warnings, and errors
  390. ## Security Features
  391. - **Secure OAuth flow** with state parameters and PKCE
  392. - **Token encryption** with secure file permissions
  393. - **Automatic validation** before each API request
  394. - **Expired token cleanup** and refresh handling
  395. - **Multi-instance coordination** prevents authentication conflicts
  396. ## Requirements
  397. - **Node.js 22+** (required for fetch API support)
  398. - **WordPress site** with the [MCP Adapter](https://github.com/WordPress/mcp-adapter) plugin installed and active
  399. - **WordPress user account** with appropriate permissions
  400. ## License
  401. GPL v2 or later
  402. ## Contributing
  403. Contributions welcome! This project is maintained by Automattic Inc.
  404. ## Support
  405. - **Issues:** [GitHub Issues](https://github.com/Automattic/mcp-wordpress-remote/issues)
  406. - **Documentation:** Check the troubleshooting section above
  407. - **WordPress MCP Plugin:** [WordPress/mcp-adapter](https://github.com/WordPress/mcp-adapter)
  408. ---
  409. **Need help?** Check the [troubleshooting section](#troubleshooting) or open an issue.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.