Scripting OpenClaw: Automating Tasks with Python SDK

If you’re running OpenClaw on a Hetzner VPS and finding yourself manually kicking off routine tasks, or worse, forgetting them entirely, then you’re missing out on the power of the OpenClaw Python SDK. While the UI is great for interactive exploration and quick prompts, many production workflows demand automation. Think daily sentiment analysis reports, scheduled content generation, or even complex multi-step agents that interact with external APIs. Manually copying and pasting prompts into the UI just isn’t scalable or reliable. This note will walk you through how to script OpenClaw using its Python SDK to automate these repetitive tasks, focusing on practical examples you can adapt for your own use cases.

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.

Setting Up Your Python Environment

Before we dive into the code, ensure your Python environment is ready. You’ll need Python 3.8+ and the openclaw SDK installed. If you’re working on a fresh Hetzner Ubuntu instance, you can typically get Python up and running with:

sudo apt update
sudo apt install python3-pip -y
pip3 install openclaw

You’ll also need your OpenClaw API key. This isn’t usually stored in a public Git repository, so the best practice is to load it from an environment variable. Add this to your ~/.bashrc or ~/.profile on your VPS:

export OPENCLAW_API_KEY="sk_your_api_key_here"

Remember to source your profile after adding it: source ~/.bashrc. The OpenClaw SDK will automatically pick up this environment variable, saving you from hardcoding it in your scripts.

Basic Interaction: Generating Text

Let’s start with a simple script to generate some text. Create a file named generate_report.py:

import os
from openclaw import OpenClaw

# Initialize the client. It will automatically pick up OPENCLAW_API_KEY from environment variables.
client = OpenClaw()

def generate_daily_summary(topic: str) -> str:
    """Generates a brief daily summary for a given topic."""
    prompt = f"Write a concise daily news summary about {topic}, focusing on key developments from the last 24 hours. Keep it under 150 words."
    response = client.completions.create(
        model="claude-haiku-4-5", # A cost-effective model for summaries
        prompt=prompt,
        max_tokens=200, # Max tokens for the model's response
        temperature=0.7 # A bit of creativity
    )
    return response.text

if __name__ == "__main__":
    summary = generate_daily_summary("AI in healthcare")
    print("--- Daily AI in Healthcare Summary ---")
    print(summary)

    # Example: Saving to a file
    with open("ai_healthcare_summary.txt", "w") as f:
        f.write(summary)
    print("\nSummary saved to ai_healthcare_summary.txt")

The non-obvious insight here is the model choice. While the OpenClaw documentation might suggest using the latest and greatest models like claude-opus-4-0, for many routine summarization or classification tasks, a smaller, faster, and significantly cheaper model like claude-haiku-4-5 is often more than sufficient. It’s about 10x cheaper per token and provides excellent quality for 90% of use cases where extreme nuance isn’t critical. Always test cheaper models first to see if they meet your needs.

To run this script:

python3 generate_report.py

Automating with Cron Jobs

Now that we have a script, the next logical step is to automate its execution. Cron is your friend here on a Linux VPS. Let’s say you want to run this daily summary script every morning at 7:00 AM.

First, ensure your Python script has the correct shebang and is executable:

chmod +x generate_report.py

Then, edit your crontab:

crontab -e

Add the following line:

0 7 * * * /usr/bin/python3 /path/to/your/scripts/generate_report.py >> /var/log/openclaw_reports.log 2>&1

A crucial detail for cron jobs is ensuring the environment variables are correctly loaded. The OPENCLAW_API_KEY won’t automatically be available to cron jobs unless you explicitly define it in the crontab or source your profile within the script itself. A safer approach for cron is to pass the key directly to the script, or make sure the cron user’s environment is set up. For simplicity, if your script directly uses the SDK, it’s better to ensure the cron job runs with the necessary environment. Alternatively, you can explicitly set it within the cron entry:

0 7 * * * OPENCLAW_API_KEY="sk_your_api_key_here" /usr/bin/python3 /path/to/your/scripts/generate_report.py >> /var/log/openclaw_reports.log 2>&1

Or, even better, ensure your script itself handles the environment variable gracefully, as shown in the Python example where it automatically picks it up. The output redirection >> /var/log/openclaw_reports.log 2>&1 is vital for debugging cron jobs; without it, you’ll have no idea if your script ran successfully or failed silently.

Handling More Complex Workflows: Multi-Turn Conversations

The OpenClaw SDK also supports multi-turn conversations, which are essential for building more dynamic agents or interactive systems. Let’s create a simple conversational agent that refines a blog post outline based on feedback:

import os
from openclaw import OpenClaw

client = OpenClaw()

def refine_blog_outline(initial_topic: str):
    """
    Simulates a multi-turn conversation to refine a blog post outline.
    """
    messages = [
        {"role": "user", "content": f"Generate a detailed outline for a blog post about '{initial_topic}'."}
    ]

    print(f"--- Generating initial outline for '{initial_topic}' ---")
    response = client.chat.completions.create(
        model="claude-haiku-4-5",
        messages=messages,
        max_tokens=500
    )
    initial_outline = response.choices[0].message.content
    print(initial_outline)
    messages.append({"role": "assistant", "content": initial_outline})

    feedback = input("\nEnter your feedback on the outline (or 'quit' to finish): ")
    while feedback.lower() != 'quit':
        messages.append({"role": "user", "content": f"Based on this feedback: '{feedback}', please refine the outline."})
        print("\n--- Refining outline based on feedback ---")
        response = client.chat.completions.create(
            model="claude-haiku-4-5",
            messages=messages,
            max_tokens=500
        )
        refined_outline = response.choices[0].message.content
        print(refined_outline)
        messages.append({"role": "assistant", "content": refined_outline})
        feedback = input("\nEnter more feedback (or 'quit' to finish): ")

    print("\n--- Final Outline ---")
    # Join messages to show the full conversation or extract the last assistant message
    print(messages[-1]['content'])

if __name__ == "__main__":
    refine_blog_outline("The Future of Serverless Computing")

This script demonstrates how to maintain a conversation history by appending both user and assistant messages to the messages list. Each subsequent call to client.chat.completions.create then sends the entire history, allowing the model to maintain context. This is crucial for interactive agents or chained tasks where the output of one step informs the next. The limitation here is that this interactive script isn’t suitable for direct cron automation due to the input() calls. You would need to replace the interactive feedback loop with pre-defined rules or external data sources for full automation.

Limitations and Resource Considerations

While OpenClaw’s SDK is

Frequently Asked Questions