How to Set Up OpenClaw Skills for Automating WordPress Sites

If you’re running OpenClaw and want to automate common tasks on your WordPress sites, leveraging OpenClaw’s skills system is a game-changer. Forget about manually logging into each site’s admin panel for routine updates or content tweaks. This guide will walk you through setting up OpenClaw skills to interact with WordPress, specifically focusing on creating a skill to manage posts and another to update plugins.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

Understanding OpenClaw Skills and WordPress API

OpenClaw skills are essentially Python functions that the OpenClaw agent can call based on its understanding of a user’s request. For these skills to interact with WordPress, they need a way to communicate with your WordPress site programmatically. The most robust method is using the WordPress REST API. By default, WordPress exposes a comprehensive REST API that allows for reading and writing data, including posts, pages, users, and more.

Before you dive into skill creation, ensure your WordPress site’s REST API is accessible. While it’s enabled by default, some security plugins might restrict access. You’ll also need authentication. For simple automation, application passwords are the most straightforward and secure method. Navigate to your WordPress admin panel, go to Users > Your Profile, scroll down to “Application Passwords,” and create a new one. This will give you a username and a unique password that OpenClaw can use to authenticate.

Setting Up the OpenClaw Environment

First, ensure your OpenClaw environment is ready. You’ll need to create a dedicated directory for your custom skills. A common practice is to have a skills/ directory within your OpenClaw configuration directory. For example, if your OpenClaw config is at ~/.openclaw/, you might create ~/.openclaw/skills/. Inside this directory, each Python file will represent a skill module.

You’ll also need a Python library to interact with the WordPress REST API. The python-wordpress-xmlrpc library is a good choice, despite its name, it supports the REST API. Install it in OpenClaw’s virtual environment or your system’s Python environment if OpenClaw is using it directly:

pip install python-wordpress-xmlrpc requests_oauthlib

Make sure this package is available to the Python interpreter that OpenClaw uses to execute skills. If you’re running OpenClaw in a Docker container, you’ll need to rebuild your image or exec into the container and install it there. For a typical VPS setup, installing it globally or within OpenClaw’s venv should suffice.

Skill 1: Creating a New WordPress Post

Let’s create a skill to publish a new post. Create a file named ~/.openclaw/skills/wordpress_posts.py with the following content:

import requests
import json
import os

# It's better to get these from environment variables or a secure config
# For simplicity in this example, we'll use direct variables
WORDPRESS_URL = os.environ.get("WORDPRESS_URL", "https://your-wordpress-site.com")
WORDPRESS_USERNAME = os.environ.get("WORDPRESS_USERNAME", "your_app_username")
WORDPRESS_PASSWORD = os.environ.get("WORDPRESS_PASSWORD", "your_app_password")

def create_wordpress_post(title: str, content: str, status: str = "publish") -> str:
    """
    Creates a new post on a WordPress site.

    Args:
        title (str): The title of the new post.
        content (str): The HTML content of the new post.
        status (str): The status of the post (e.g., "publish", "draft", "pending").

    Returns:
        str: A message indicating success or failure, including the post URL if successful.
    """
    if not all([WORDPRESS_URL, WORDPRESS_USERNAME, WORDPRESS_PASSWORD]):
        return "Error: WordPress credentials or URL not configured."

    api_url = f"{WORDPRESS_URL}/wp-json/wp/v2/posts"
    headers = {
        "Content-Type": "application/json"
    }
    auth = (WORDPRESS_USERNAME, WORDPRESS_PASSWORD)

    data = {
        "title": title,
        "content": content,
        "status": status,
    }

    try:
        response = requests.post(api_url, headers=headers, auth=auth, data=json.dumps(data), timeout=10)
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)

        post_data = response.json()
        post_link = post_data.get("link")
        return f"Successfully created WordPress post: '{title}'. URL: {post_link}"
    except requests.exceptions.HTTPError as e:
        return f"HTTP error creating WordPress post: {e.response.status_code} - {e.response.text}"
    except requests.exceptions.RequestException as e:
        return f"Network error creating WordPress post: {e}"
    except Exception as e:
        return f"An unexpected error occurred: {e}"

A crucial non-obvious insight here: While the python-wordpress-xmlrpc library is powerful, for simple REST API calls like creating a post, directly using the requests library gives you more fine-grained control and often results in cleaner, more readable code. It also avoids potential dependency conflicts that might arise from larger, more opinionated libraries. Always prioritize direct REST calls for straightforward interactions. Make sure to set your WORDPRESS_URL, WORDPRESS_USERNAME, and WORDPRESS_PASSWORD as environment variables in the OpenClaw process or directly in the skill file for testing. For production, environment variables are highly recommended for security.

Skill 2: Updating WordPress Plugins

Updating plugins is another common task. The WordPress REST API doesn’t have a direct endpoint for “update all plugins” but you can update individual plugins. For this example, let’s create a skill to activate or deactivate a plugin, as updating often involves these states.

Add the following function to your ~/.openclaw/skills/wordpress_plugins.py file:

import requests
import json
import os

WORDPRESS_URL = os.environ.get("WORDPRESS_URL", "https://your-wordpress-site.com")
WORDPRESS_USERNAME = os.environ.get("WORDPRESS_USERNAME", "your_app_username")
WORDPRESS_PASSWORD = os.environ.get("WORDPRESS_PASSWORD", "your_app_password")

def manage_wordpress_plugin(plugin_slug: str, action: str) -> str:
    """
    Activates or deactivates a specific WordPress plugin.

    Args:
        plugin_slug (str): The slug of the plugin (e.g., 'akismet/akismet.php').
        action (str): The desired action: 'activate' or 'deactivate'.

    Returns:
        str: A message indicating success or failure.
    """
    if not all([WORDPRESS_URL, WORDPRESS_USERNAME, WORDPRESS_PASSWORD]):
        return "Error: WordPress credentials or URL not configured."
    if action not in ["activate", "deactivate"]:
        return "Error: Action must be 'activate' or 'deactivate'."

    api_url = f"{WORDPRESS_URL}/wp-json/wp/v2/plugins/{plugin_slug}"
    headers = {
        "Content-Type": "application/json"
    }
    auth = (WORDPRESS_USERNAME, WORDPRESS_PASSWORD)

    data = {
        "status": "active" if action == "activate" else "inactive"
    }

    try:
        response = requests.post(api_url, headers=headers, auth=auth, data=json.dumps(data), timeout=10)
        response.raise_for_status()

        plugin_data = response.json()
        current_status = "active" if plugin_data.get("status") == "active" else "inactive"
        return f"Successfully set plugin '{plugin_slug}' to '{current_status}' status."
    except requests.exceptions.HTTPError as e:
        return f"HTTP error managing WordPress plugin: {e.response.status_code} - {e.response.text}"
    except requests.exceptions.RequestException as e:
        return f"Network error managing WordPress plugin: {e}"
    except Exception as e:
        return f"An unexpected error occurred: {e}"

The trick here is finding the correct plugin_slug. This isn’t just the plugin folder name; it’s typically the folder name followed by the main plugin file (e.g., akismet/