Menu

Mattering Automations WordPress integration

Connect a self-hosted WordPress site to Mattering Automations: posts, pages, media with upload from URL, comment moderation, categories, tags, users, plugins, and site settings as workflow steps, authenticated with an application password generated on your own site.

The Mattering Automations WordPress integration adds your site's REST API to the automation canvas: create, update, and publish posts and pages, pull files into the media library from a URL, moderate comments, manage categories and tags, administer users, activate and deactivate plugins, read and change site settings, list installed themes, search the whole site, and read post revision history.

WordPress is self-hosted, so the credential is per-site: the site URL, a WordPress username, and an application password that user generates on their own profile page. Application passwords have shipped in WordPress core since 5.6 and authenticate REST requests served over https using Basic auth, and every request acts with the owning user's role, which is the integration's whole permission model. Setup takes a few minutes and this guide walks through each step, including which role each node family needs, and ends with the full node reference.

Deletion follows WordPress's own trash-versus-force split, stated on the nodes rather than buried. WordPress: Delete Post, WordPress: Delete Page, and WordPress: Delete Comment default to the recoverable trash, while four nodes are flagged destructive because WordPress gives their targets no trash at all: WordPress: Delete Media (the file goes with it), WordPress: Delete Category, WordPress: Delete Tag, and WordPress: Delete User. Some write surfaces are deliberately absent: plugin install and delete stay in wp-admin because they put runtime PHP on the site, theme activation has no endpoint in core's REST surface, and revision deletes erase history for near-zero automation value.

Before you start

  • A self-hosted WordPress site on version 5.6 or later, served over https. Application passwords ship with core from 5.6 and are scoped to requests served over https, and the integration refuses plain http site URLs for the same reason.
  • A WordPress user whose role matches what your workflows will do: an Editor covers posts, pages, media, and comment moderation, while the user, plugin, theme, and site settings nodes need an Administrator. A dedicated automation user with the lowest sufficient role is the tidy setup.
  • The Application Passwords section visible on that user's profile page in wp-admin. It is part of core on https sites; if the section is missing, a security plugin or host setting has disabled it and needs to allow it before you can continue.
  • A Mattering workspace with access to the Automations app.
  • Your site URL exactly as the site serves it, with https. A pasted wp-json path is tolerated and stripped, but the credential wants the site root, like https://your-site.com.

Generate a WordPress application password

Mattering authenticates to your site with an application password over Basic auth: the WordPress username is the Basic username and the generated application password is the Basic password. An application password is not the account's login password. It is a separate credential the user creates for one integration and can revoke alone, and every request made with it acts with that user's role, so the user you generate it under decides exactly what the automation can do.

Sign in to wp-admin on your site and open Users, then Profile. To generate the credential for a different account, an Administrator can open Users, then All Users, and edit that user instead.
Scroll to the Application Passwords section near the bottom of the page.
Enter a name that says what it is for, like Mattering Automations, and click Add New Application Password.
Copy the password now. WordPress shows it once, on this screen only; after you leave, it can never be viewed again and your options are revoking it or generating a new one. The spaces WordPress displays in the password are fine to keep; both the spaced and unspaced forms work.
The credential inherits its user's role, and that is the most common source of confusion later: a connection made from an Editor account verifies cleanly and works for every content node, then is refused by the user, plugin, and settings nodes, which need an Administrator. If some nodes work and others return permission errors, check the role before anything else.

Connect WordPress to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose WordPress from the list.
Click Create new credential and fill the three fields: the site URL (https), the WordPress username, and the application password. Then save.
The application password is stored encrypted in Google Secret Manager and never appears in workflow logs. The site URL is normalized for you: a bare hostname gets https added, a pasted wp-json suffix is stripped, and an explicit http:// URL is refused, because Basic auth over plain http would expose the credential in transit.
Click Test Connection. Mattering calls your site's own users/me endpoint, which answers for any authenticated user regardless of role: a result naming your user proves the credential, an error means the site URL, username, or password is wrong, or the application password was revoked.
Click Connect. All 48 WordPress nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: a WordPress section should list the query and action nodes. Drop WordPress: Get Current User onto the canvas and run a test step. It is the integration's universal probe: it calls the site's users/me endpoint, works for any authenticated user no matter the role, and a successful response returns the credential user's id, display name, and slug without echoing the password. If this node succeeds, the credential is healthy; anything failing after it is a role or parameters question, not an authentication one.

Next, run WordPress: List Posts and copy a post ID, because the get, update, delete, and revision nodes all take one, and note that list responses return up to 100 items per page. If your workflows will manage users, plugins, or settings, also run WordPress: Get Site Settings now: it needs an Administrator credential, so it is the quickest way to learn whether your user's role covers the administrative node families before a workflow depends on them. Everything in this verify path is read-only: it cannot reach the four destructive nodes or change a single setting, so it is safe to re-run whenever you rotate the application password.

Node reference

48 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 25

WordPress: Get Comment

wordpress_get_comment

Fetch one comment: commenter name, content (rendered object), status, parent, and the post it belongs to.

WordPress: Get Current User

wordpress_get_current_user

Fetch the user the stored Application Password belongs to: id, display name, and slug (context=edit adds email, roles, and capabilities). Any authenticated user can call it, so this is the credential health check to run first in any WordPress automation.

WordPress: Get Media

wordpress_get_media

Fetch one media item: source_url (the direct file URL), MIME type, alt text, caption, and the generated size variants under media_details.

WordPress: Get Page

wordpress_get_page

Fetch one page: title/content/excerpt (rendered objects), status, parent, menu order, and template.

WordPress: Get Plugin

wordpress_get_plugin

Fetch one installed plugin: status, version, author, and WordPress/PHP version requirements. Needs an Administrator credential.

WordPress: Get Post

wordpress_get_post

Fetch one post: title, content, and excerpt (each as {rendered: ...} objects), status, author, featured media, and assigned category/tag IDs.

WordPress: Get Post Status

wordpress_get_post_status

Fetch one post status by its slug: name and its public/private/protected/queryable flags.

WordPress: Get Post Type

wordpress_get_post_type

Fetch one post type by its slug: name, hierarchy flag, associated taxonomies, and rest_base route.

WordPress: Get Site Settings

wordpress_get_settings

Read the site's settings in one call: title, tagline, admin email, timezone, date/time formats, language, default category, posts per page, front-page configuration, and default comment/ping status. Needs an Administrator credential.

WordPress: Get Taxonomy

wordpress_get_taxonomy

Fetch one taxonomy by its slug: name, hierarchy flag, associated post types, and rest_base route.

WordPress: Get User

wordpress_get_user

Fetch one user: display name, slug, description, and avatar URLs (context=edit adds email, roles, and capabilities).

WordPress: List Categories

wordpress_list_categories

List categories with their term IDs, names, slugs, hierarchy, and per-term post counts. Sorted by name ascending by default.

WordPress: List Comments

wordpress_list_comments

List comments with filters on post, commenter email, status (approve is the default; hold/spam/trash need an authorized user), and date range. The moderation-queue read: status=hold lists comments awaiting approval.

WordPress: List Media

wordpress_list_media

List media-library items (attachments) with filters on search text, media type (image, video, audio, text, application), MIME type, and date ranges. Returns media IDs used by the update/delete nodes and by featured-image fields.

WordPress: List Pages

wordpress_list_pages

List pages with filters on search text, author, slug, status, menu order, and date ranges. Returns page IDs used by the get, update, and delete nodes. Totals arrive in the X-WP-Total response header: page by incrementing page.

WordPress: List Plugins

wordpress_list_plugins

List installed plugins with their identifiers (dir/file form), names, versions, and active/inactive status. Needs an Administrator credential. The site-audit read behind version-monitoring automations.

WordPress: List Post Revisions

wordpress_list_post_revisions

List a post's saved revisions: each carries the revision id, author, date, and the title/content/excerpt as of that save. The audit trail for edit-tracking automations.

WordPress: List Post Statuses

wordpress_list_post_statuses

List the site's registered post statuses (publish, future, draft, pending, private, trash) as an object keyed by status slug, each with its visibility flags.

WordPress: List Post Types

wordpress_list_post_types

List the site's registered post types (post, page, attachment, plus any custom types) as an object keyed by type slug, each with its taxonomies and rest_base route, the discovery call for sites with custom content types.

WordPress: List Posts

wordpress_list_posts

List posts with filters on search text, author, category, tag, status, slug, and publish/modified date ranges. Returns post IDs used by the get, update, and delete nodes. Totals arrive in the X-WP-Total response header (not carried in the node output): page by incrementing page until a short page comes back.

WordPress: List Tags

wordpress_list_tags

List tags with their term IDs, names, slugs, and per-term post counts. Sorted by name ascending by default.

WordPress: List Taxonomies

wordpress_list_taxonomies

List the site's registered taxonomies (built-in category and post_tag plus any custom ones) as an object keyed by taxonomy slug, each with its rest_base route and the post types it applies to.

WordPress: List Themes

wordpress_list_themes

List installed themes with their stylesheet identifiers, names, versions, and active/inactive status. Read-only: core's REST surface has no theme-activation endpoint, so this connector reports themes rather than switching them.

WordPress: List Users

wordpress_list_users

List the site's users with their IDs, display names, and slugs (context=edit adds emails and roles). Unauthorized requests only see users with published content.

WordPress: Search Site Content

wordpress_search

Search across the site's content in one call: returns lightweight results (id, title, url, type, subtype) spanning posts, pages, and other public post types - the find-it-first step before a get node.

Action nodes 23

WordPress: Activate or Deactivate Plugin

wordpress_set_plugin_status

Activate or deactivate an installed plugin by setting its status. Fully reversible (set the opposite status), but note a plugin toggle changes live site behavior the moment it lands. Needs an Administrator credential. Installing or deleting plugins is deliberately not offered by this connector.

WordPress: Create Category

wordpress_create_category

Create a category. Reversible with WordPress: Delete Category.

WordPress: Create Comment

wordpress_create_comment

Create a comment on a post, optionally as a reply to another comment. Authenticated requests comment as the credential's user unless author fields are set (setting arbitrary author fields needs moderation permission). Reversible with WordPress: Delete Comment (default delete is the trash).

WordPress: Create Page

wordpress_create_page

Create a page. Defaults to a draft; set status to publish to go live. Reversible with WordPress: Delete Page (default delete is the trash).

WordPress: Create Post

wordpress_create_post

Create a post. Defaults to a draft; set status to publish to go live immediately, or to future with a date to schedule. Reversible with WordPress: Delete Post (default delete is the trash).

WordPress: Create Tag

wordpress_create_tag

Create a tag. Reversible with WordPress: Delete Tag.

WordPress: Create User

wordpress_create_user

Create a user account (username, email, and password are required by the API). Needs an Administrator credential. Reversible with WordPress: Delete User.

WordPress: Delete Category

wordpress_delete_category

DESTRUCTIVE: delete a category, permanently - per the vendor docs force is required to be true, as terms do not support trashing. Posts in the category are not deleted; they fall back to the default category.

WordPress: Delete Comment

wordpress_delete_comment

Move a comment to the trash (the default), restorable from wp-admin. force=true bypasses the trash and deletes PERMANENTLY.

WordPress: Delete Media

wordpress_delete_media

DESTRUCTIVE: delete a media item AND its file from the uploads directory, permanently. Attachments only support a recoverable trash when the site defines the MEDIA_TRASH constant (off by default), so force defaults to true here; on a default site a force-less delete is rejected by WordPress. Posts using the file keep broken references.

WordPress: Delete Page

wordpress_delete_page

Move a page to the trash (the default), restorable from wp-admin. force=true bypasses the trash and deletes PERMANENTLY.

WordPress: Delete Post

wordpress_delete_post

Move a post to the trash (the default), where it can be restored from wp-admin for 30 days. force=true bypasses the trash and deletes PERMANENTLY - content and revisions are gone.

WordPress: Delete Tag

wordpress_delete_tag

DESTRUCTIVE: delete a tag, permanently - per the vendor docs force is required to be true, as terms do not support trashing. Tagged posts keep their other tags.

WordPress: Delete User

wordpress_delete_user

DESTRUCTIVE: delete a user account, permanently - per the vendor docs force is required to be true, as users do not support trashing. Their posts and links are handed to the reassign user (required by the API). Application passwords owned by the deleted user stop working.

WordPress: Update Category

wordpress_update_category

Update a category's name, description, slug, or parent; only the fields you fill are changed.

WordPress: Update Comment

wordpress_update_comment

Update a comment; only the fields you fill are changed. THE MODERATION NODE: set status to approved to approve a held comment, hold to unapprove, or spam to mark it spam, each reversible by writing the previous status back.

WordPress: Update Media

wordpress_update_media

Update a media item's metadata: title, alt text, caption, description, associated post, or author. The file itself is not changed. Only the fields you fill are sent.

WordPress: Update Page

wordpress_update_page

Update fields on an existing page; only the fields you fill are changed. Publish a draft, re-parent the page, or swap its template.

WordPress: Update Post

wordpress_update_post

Update fields on an existing post; only the fields you fill are changed. The workhorse edit: publish a draft (status=publish), retitle, swap the featured image, or reassign categories.

WordPress: Update Site Settings

wordpress_update_settings

Change site settings; only the fields you fill are sent. Reversible by writing the previous values back (read them first with WordPress: Get Site Settings). Needs an Administrator credential.

WordPress: Update Tag

wordpress_update_tag

Update a tag's name, description, or slug; only the fields you fill are changed.

WordPress: Update User

wordpress_update_user

Update fields on a user; only the fields you fill are changed. Changing roles or passwords needs an Administrator credential.

WordPress: Upload Media from URL

wordpress_upload_media_from_url

Upload a file into the media library from a public URL: the node downloads the file (up to 50 MB) and re-uploads the bytes to WordPress, which is how the REST API takes uploads (core has no create-from-URL endpoint of its own). The site's own upload_max_filesize still applies. Returns the new attachment with its media ID and source_url. Reversible with WordPress: Delete Media.

Using the integration

On the automation canvas

WordPress nodes chain with every other node: a form submission can become a draft through WordPress: Create Post and then open a review task in Mattering Productivity, a scheduled sweep can read WordPress: List Plugins across your sites and write versions into a Mattering database, and WordPress: List Comments can feed a moderation digest. Post IDs from WordPress: List Posts and user IDs from WordPress: List Users are the two values most downstream nodes ask for, and WordPress: Search Site Content is the find-it-first step when a workflow starts from a phrase rather than an ID.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter can drive the same surface. An agent can find a post with WordPress: Search Site Content, read it with WordPress: Get Post, fix it with WordPress: Update Post, and the edit lands in the site's own revision history that WordPress: List Post Revisions reads. WordPress also ships an official MCP adapter of its own, built on core 6.9's Abilities API, aimed at connecting an assistant directly to one site; this integration is the fit when WordPress is one step in a workflow that spans other tools, and it needs nothing installed on the site.

Drafts, schedules, and the publish moment

WordPress: Create Post and WordPress: Create Page default to drafts, which makes them safe to wire to triggers: content exists but nothing is public until a workflow says so. Set status to publish at creation to go live immediately, or to future with a date to schedule. The publish moment usually belongs to WordPress: Update Post, the workhorse edit node: it changes only the fields you fill, so flipping status to publish touches nothing else, and the same node retitles, swaps the featured image from a media ID, or reassigns categories.

Comment moderation as a workflow

WordPress: List Comments with status set to hold reads the moderation queue; approved comments are the default view, and the hold, spam, and trash views need the authenticated credential. WordPress: Update Comment is the moderation lever: write status approved to approve, hold to unapprove, or spam to flag, each reversible by writing the previous status back. WordPress: Delete Comment defaults to the trash, so even a cleanup pass is recoverable from wp-admin unless a workflow explicitly sets force.

Trash versus force, the delete model

The integration keeps WordPress's own semantics instead of flattening them. Post, page, and comment deletes default to the trash: WordPress: Delete Post is restorable from wp-admin for 30 days by default, and force is an explicit, deliberate escalation that skips the trash and is permanent. The four destructive-flagged nodes are the ones WordPress itself gives no trash: WordPress: Delete Media removes the file from the uploads directory (attachments only support trash when a site opts in with the MEDIA_TRASH constant, which is off by default), WordPress: Delete Category and WordPress: Delete Tag are immediate (posts keep their other terms and fall back to the default category), and WordPress: Delete User requires a reassign user to inherit the deleted account's posts. Keep all four behind conditions, approval tasks, or manual runs.

Media from a URL, and what stays off the canvas

Core WordPress has no upload-from-URL endpoint, so WordPress: Upload Media from URL downloads the file from a public https URL, up to 50 MB, and re-uploads the bytes to your site in the shape the REST API expects, returning the new attachment's media ID and direct file URL; the site's own upload size limit still applies, and WordPress: Update Media sets alt text and captions afterward. Three boundaries are deliberate. Plugin install and delete are not shipped, because adding or removing runtime PHP is site administration too sharp for a generic node; WordPress: Activate or Deactivate Plugin is the reversible lever that is shipped. Theme switching has no core REST endpoint, so WordPress: List Themes reports honestly instead of pretending. And revision deletes are absent because erasing history has near-zero automation value; WordPress: List Post Revisions keeps the reading side first-class.

Troubleshooting

Test Connection fails with an authentication error
The users/me probe accepts any authenticated user, so a failure here is about the credential itself. Check the username is the WordPress username for the account that generated the application password, check the password for copy errors (the spaces WordPress displays are fine; both spaced and unspaced forms work), and confirm the application password still exists on the user's profile page, since revoking it there kills the credential instantly. If the account's login password was pasted instead of a generated application password, that is the problem: the integration authenticates with application passwords.
The credential is refused before the site is ever called, with an error about the URL
The integration requires https and refuses explicit http:// site URLs, because application passwords are scoped to requests served over https and Basic auth over plain http would expose the credential in transit. Enter the site root with https, like https://your-site.com. A bare hostname gets https added for you, and a pasted wp-json path is stripped, but a site that genuinely does not serve https cannot be connected until it does.
There is no Application Passwords section on the user's profile page
Application passwords are part of WordPress core from 5.6, but the section only appears when WordPress considers the site eligible, and it can be switched off. The usual causes: the site is served over plain http rather than https, a security plugin has disabled application passwords, or the host has turned them off. Serve the site over https and check the security plugin's settings; once the section appears, generate the password normally.
Content nodes work but the user, plugin, theme, or settings nodes return permission errors
The credential's user does not have a high enough role. Every request acts as the user who generated the application password, and the connection test passes for any authenticated user regardless of role, so an Editor credential verifies cleanly, runs every post, page, media, and comment node, and is then refused by WordPress: List Users with context=edit, WordPress: List Plugins, WordPress: Get Site Settings, and their siblings, which need an Administrator. Generate a new application password under an Administrator account, or accept the boundary if the automation should not have administrative reach.
WordPress: Delete Media deletes permanently even though other deletes go to the trash
That is WordPress's own rule, not the integration's. Attachments only support a recoverable trash when the site defines the MEDIA_TRASH constant, which is off by default, and on a default site WordPress rejects a media delete that does not force. The node therefore defaults force to true so the call succeeds, and it is flagged destructive for exactly that reason: the file is removed from the uploads directory, and posts that used it keep broken references. Read the item first with WordPress: Get Media and keep the node behind a condition or approval step.
List nodes return only some of the items
The REST API paginates: list endpoints default to 10 items and cap per_page at 100, so a site with 400 posts answers a single call with one page, not everything. Set per_page up to 100 and page by incrementing the page parameter until a short page comes back. WordPress reports totals in the X-WP-Total and X-WP-TotalPages response headers, which are not carried in the node output, so the short-page pattern is the practical stop condition inside a workflow.
Requests slow down, time out, or return throttling errors during a large sweep
WordPress core documents no REST rate limit of its own, so the bound is the hosting: managed WordPress hosts commonly throttle API traffic, and a small server simply runs out of headroom. The site is also serving your visitors from the same resources, so a heavy sweep competes with real traffic. Spread scheduled audits apart, prefer one filtered list call over many get calls, use per_page 100 to cut request counts, and schedule wide sweeps off-peak. If a host throttles consistently, its own documentation is the place to learn the actual limits.
WordPress: Upload Media from URL fails on a file that seems reasonable
Two ceilings apply, and either can be the one hit. The node downloads the file before re-uploading it and caps the download at 50 MB, and the source must be a public https URL the node can reach without credentials. Past that, the upload lands under the site's own upload_max_filesize limit, which many hosts set well below 50 MB, and WordPress refuses files whose type the site does not allow. Check the site's media settings and the host's PHP upload limits, and confirm the URL serves the raw file rather than an HTML page around it.

WordPress is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products