7 OpenClaw Automations for Small Businesses in Southeast Asia

What you’re building

OpenClaw reads incoming WhatsApp messages, matches them against a knowledge base you maintain in Google Sheets, responds within your defined task scope, and routes anything outside scope to a staff member’s WhatsApp number. No application code required.

Reference skill

Install 1kalin/afrexai-support-operations from ClawHub to study the escalation framework and response templating structure. You won’t deploy it directly.

Components needed

• Google Sheets (your live knowledge base: questions, answers, keywords, categories)
• Google Sheets MCP (so OpenClaw can read and update the sheet)
• A custom SKILL.md file (defines task scope and response behaviour)
• WhatsApp Business API (already connected)
• OpenClaw agent bindings (to isolate this agent to the support channel only)

Step 1: Build your knowledge base in Google Sheets. Create a sheet with four columns: Question, Answer, Keywords, Category. Populate it with your 20–30 most common customer queries. This is the file your agent reads at runtime, so it stays updated without touching OpenClaw’s config.

Step 2: Install the Google Sheets MCP so OpenClaw can query the sheet on each incoming message. The MCP requires OAuth authorisation. Follow the setup in OpenClaw’s MCP documentation.

Step 3: Write a custom SKILL.md using afrexai-support-operations as your structural reference. The skill file must define: (a) the task scope explicitly: order status, FAQs, return policy, nothing else; (b) instructions to query the Sheets knowledge base for each incoming message; (c) escalation trigger keywords (refund, complaint, urgent, human); (d) the escalation destination WhatsApp number; and (e) the fallback message for queries outside scope.

Step 4: Isolate the agent using bindings. In openclaw.json, configure this agent’s bindings to accept only messages from your support channel. Restrict its skills array to only the support skill. An empty or minimal skills list prevents the agent from accessing tools it should never touch. Anything outside the defined task scope returns your fallback message and forwards to the team. This is an architectural guardrail, not just a prompt instruction.

Step 5: Set up escalation. The staff member receiving escalations needs WhatsApp on that number. Configure the escalation message to include the customer’s original message for context so the human responder doesn’t start blind.

Step 6: Run 48-hour supervised mode. Review every conversation for the first two days. Add missed query patterns to your Sheets knowledge base as they surface.

Third-party costs

• WhatsApp Business API: ~$0.02–0.08 per conversation (Meta’s pricing; user-initiated conversations are cheaper than business-initiated)
• Google Sheets MCP: free
• Google Sheets: free

What you’re building

A 7am WhatsApp summary covering overnight orders, unread emails by priority, today’s calendar, and any flagged tasks, delivered on schedule and also available on demand throughout the day.

Start from

1kalin/morning-daily-briefing on ClawHub, production-ready and the recommended starting point. Install it directly.

openclaw skills install 1kalin/morning-daily-briefing

Components needed

• Gmail MCP (for email data)
• Google Calendar MCP (for today’s schedule)
• Google Sheets MCP (for daily sales or order data, if you track it in Sheets)
• Heartbeat config in openclaw.json

Step 1: Install the skill and MCPs. Each MCP requires a separate OAuth authorisation flow. Follow the connector setup in OpenClaw’s MCP documentation for Gmail and Google Calendar before testing. Grant read access at minimum; write access if you want the agent to mark emails as read.

Step 2: Set the heartbeat in openclaw.json:

{
  "agents": {
    "defaults": {
      "heartbeat": {
        "every": "30m",
        "target": "last",
        "directPolicy": "allow"
      }
    }
  }
}

This keeps OpenClaw polling for scheduled tasks. The morning-briefing skill registers its own daily trigger at the delivery time you configure in the skill’s config file.

Step 3: Configure the skill. In the skill’s config file (in the skill directory after install), set: which Gmail labels to prioritise, which Google Calendar to read, the Sheets tab containing your daily summary, delivery time, and summary length.

Step 4: Set model routing in openclaw.json to keep costs low for this routine summarisation task:

{
  "agents": {
    "defaults": {
      "model": "google/gemini-2.0-flash-lite"
    }
  }
}

Step 5: Test with a manual trigger. Ask your agent “Brief me” to run the briefing on demand. Adjust the skill config until the output covers what you actually need. Only then let the scheduled trigger take over.

Gotchas

• Model routing lives in openclaw.json, not SOUL.md.
• OAuth tokens for Gmail and Google Calendar expire periodically. If your briefing stops arriving, check token validity first.
• The skill delivers a partial briefing if a data source is unavailable rather than failing silently. This is correct behaviour, not a bug.

Third-party costs

• Gmail and Google Calendar: free for personal use; Google Workspace ~$6/user/month for a business domain
• Gemini Flash Lite API: roughly $0.50–1.50/day for briefings plus general chat at moderate usage

What you’re building

OpenClaw reads invoice emails as they arrive, extracts vendor, amount, line items, and invoice date via DocStrange, pushes the structured data to Xero or a Google Sheets ledger, flags anomalies (duplicates, unexpected amounts, unknown vendors) via WhatsApp, and sends a daily 6pm summary of what was processed.

Start from

shhdwi/docstrange on ClawHub for the extraction layer.

openclaw skills install shhdwi/docstrange

Components needed

• Gmail MCP (to read invoice emails and attachments)
• DocStrange API key (from nanonets.com, free tier: 500 pages/month)
• Xero MCP or Google Sheets MCP (for the output destination)
• Daily cron for the status summary

Step 1: Create a dedicated invoice Gmail label. Set up a Gmail filter to auto-label emails from your suppliers with “Invoices”. This gives DocStrange a clean, targeted inbox to watch.

Step 2: Install DocStrange and configure your API key. Get your key from nanonets.com, then add DOCSTRANGE_API_KEY as an environment variable on your VPS. Set up the skill’s extraction schema to return: vendor name, invoice number, invoice date, line items, total amount, and currency.

Step 3: Install the Gmail MCP and authorise it to read attachments from your Invoices label.

Step 4: Enable the Lobster plugin in openclaw.json. Lobster is OpenClaw’s deterministic workflow shell. It lets you pause the pipeline after extraction and wait for your explicit approval before writing anything to your accounting system:

{
  "tools": {
    "alsoAllow": ["lobster"]
  }
}

Step 5: Define the Lobster pipeline in a .lobster file in your workspace. The pipeline extracts invoice data, sends you a WhatsApp preview, then only commits to Xero or Sheets after you approve:

name: invoice-triage
steps:
  - id: extract
    command: docstrange.extract --source gmail-invoices
  - id: preview
    command: whatsapp.notify --preview-from-stdin
    stdin: $extract.stdout
    approval: required
  - id: commit
    command: sheets.append --ledger invoices
    stdin: $extract.stdout
    condition: $preview.approved

When the pipeline hits approval: required, it returns a resumeToken and waits. You review the WhatsApp summary, reply to approve, and the commit step runs. Disapprove and nothing is written.

Step 6: Connect your accounting output. For Xero or QuickBooks: check the OpenClaw MCP docs for verified integrations. If you’re not on either yet, the Google Sheets MCP is simpler. Create a ledger sheet with columns for Date, Vendor, Invoice Number, Amount, Category, Currency, Status.

Step 7: Define your anomaly rules in SOUL.md: flag duplicate invoice numbers, amounts more than 20% above your historical average for that vendor, and invoices from unrecognised senders.

Step 8: Set a daily 6pm summary cron in openclaw.json. The summary should report: invoices processed today, total value, any anomalies flagged, and items awaiting your review.

Step 9: Test with 5 real invoices before enabling full automation. Check extraction accuracy per field, confirm Xero or Sheets entries are correct, and verify anomaly alerts fire as expected.

Third-party costs

• DocStrange/Nanonets: free up to 500 pages/month; ~$0.08/page above that
• Xero: $15–40/month depending on your SEA market plan
• QuickBooks: $10–25/month
• Google Sheets: free (if used as output instead of accounting software)

What you’re building

When a new post publishes on your website, OpenClaw detects it via RSS, generates platform-adapted versions (Facebook caption, Instagram caption with hashtags, LinkedIn excerpt), sends drafts to your WhatsApp for approval, and schedules them to post at your configured times after you approve.

Path A: via PostSyncer (faster setup, adds SaaS dependency)

Install abakermi/openclaw-postsyncer from ClawHub:

openclaw skills install abakermi/openclaw-postsyncer

1. Create a PostSyncer account at postsyncer.com and connect your Facebook Page, Instagram Business account, and LinkedIn Company Page there
2. Get your PostSyncer API key from Settings and add POSTSYNCER_API_KEY as an environment variable on your VPS
3. Configure an RSS trigger in SOUL.md to detect new posts from your blog feed
4. Write a content adaptation prompt in SOUL.md that generates platform variations (character limits, hashtag counts, tone adjustments per platform)
5. Enable Lobster in openclaw.json ("tools": { "alsoAllow": ["lobster"] }) and define a .lobster pipeline with an approval: required gate between draft generation and the PostSyncer queue call. The pipeline sends drafts to your WhatsApp and waits for your confirmation before scheduling anything. This prevents bad drafts from going live without your review.

Path B: direct API (no extra SaaS, more setup)

1. Register a Meta Developer app at developers.facebook.com and generate a long-lived Page access token covering your Facebook Page and linked Instagram Business account
2. Register a LinkedIn Developer app and get a Company Page access token
3. Enable Lobster ("tools": { "alsoAllow": ["lobster"] }) and write a .lobster pipeline: RSS trigger → generate variants → approval: required WhatsApp preview → Meta Graph API call + LinkedIn API call on approval
4. Write the content generation skill in SOUL.md and store access tokens as environment variables on your VPS
5. Set a calendar reminder to refresh Meta tokens every 60 days (they expire; LinkedIn tokens last longer)

Gotchas

• Instagram requires a Business or Creator account linked to a Facebook Page. Personal accounts cannot receive automated posts via API
• LinkedIn’s API rate limits restrict posting frequency; posting more than once per hour on a single Company Page can trigger temporary restrictions
• For Thailand, LINE does not have an open scheduling API. LINE posts require the LINE Messaging API and a separate integration not covered by PostSyncer or OpenClaw natively

Third-party costs

• PostSyncer (Path A): free tier limited to a small number of scheduled posts; paid plans ~$10–20/month
• Meta Developer app (Path B): free, requires business verification
• LinkedIn API (Path B): free for Company Page posts

What you’re building

A customer messages your WhatsApp number to book. The agent checks your Google Calendar for available slots, confirms a time, creates the event, and sends WhatsApp reminders 24 hours and 2 hours before the appointment.

Start from

toughworm/advanced-calendar on ClawHub.

openclaw skills install toughworm/advanced-calendar

Components needed

• Google Calendar MCP (for live read/write. Write access is required, not just read)
• WhatsApp Business API (already connected)
• Cron for reminder messages

Step 1: Install advanced-calendar and the Google Calendar MCP. During the OAuth consent flow, grant write scope (calendar.events). Read-only access will allow the agent to check availability but silently fail when creating bookings.

Step 2: Configure your booking parameters in the skill config: available hours (e.g. 09:00–18:00), working days, appointment duration, buffer time between slots, and how far in advance someone can book.

Step 3: Write your booking script in SOUL.md. Define: the opening message when someone says “book” or “appointment”, the confirmation message format, and the cancellation handling. Keep responses short: WhatsApp replies, not email..

Step 4: Set up the reminder cron. In openclaw.json, add a cron that checks every hour for appointments in the next 24 hours and 2 hours, and sends WhatsApp messages to customers who haven’t yet received a reminder. Store sent-reminder state in a Sheets log or local file to prevent double-sends.

Step 5: Isolate the booking agent. In openclaw.json, restrict this agent’s skills array to only the booking and calendar skills. Use bindings to route only booking-intent messages here; everything else goes to your general support flow or returns a fallback message.

Step 6: Test end-to-end. Use a test number to book, receive confirmation, check the calendar entry, and verify both reminder messages fire at the right times. Also test cancellation: the agent should update the calendar and confirm to the customer.

Third-party costs

• Google Calendar API: free
• WhatsApp Business API: ~$0.02–0.08 per reminder message (each reminder opens a business-initiated conversation)

What you’re building

A daily agent that checks defined competitor product pages on Lazada, Shopee, or Tokopedia, extracts current prices, compares them against your baseline, sends a WhatsApp alert when a competitor undercuts your threshold, and produces a weekly price movement summary.

Reference skill

Install 1kalin/afrexai-web-scraping-engine from ClawHub to study the architecture and anti-detection patterns. Use it as your design reference, not a deployable skill.

Components needed

• Playwright MCP (headless browser for JS-rendered marketplace pages)
• Google Sheets MCP (for your URL list, price baseline, and history log)
• A custom SKILL.md for the monitoring and comparison logic
• Daily cron and weekly summary cron

Step 1: Build your competitor URL list in Google Sheets. Create a sheet with columns: Product Name, Competitor, URL, Your Price, Alert Threshold, Last Checked Price, Last Checked Date. Start with your top 20–50 SKUs.

Step 2: Install the Playwright MCP. Playwright is open source and gives OpenClaw a headless browser that can load JavaScript-rendered pages and extract text from the DOM. This is what makes Lazada and Shopee prices visible to the scraper.

Step 3: Write a custom SKILL.md using afrexai-web-scraping-engine as your architecture reference. The skill should: read the URL list from Sheets, use Playwright to load each page, extract the price element, compare to your threshold, and write the result back to Sheets.

Step 4: Identify CSS selectors for each marketplace. Open a competitor product page, right-click the price, and select “Inspect” in your browser. Note the CSS class for the price element on Lazada and Shopee. Add these to your Sheets URL list so the skill knows which selector to use per domain.

Step 5: Configure the daily cron in openclaw.json to run the monitoring skill at 8am each day.

Step 6: Set the alert trigger in SOUL.md: if any competitor price drops below (your price minus threshold), send an immediate WhatsApp alert with the product name, competitor, their current price, and your price.

Step 7: Add a Monday morning summary cron. The agent reads 7 days of price history from Sheets and sends a summary of which products saw movements during the week.

Gotchas

• Marketplace page structures change when platforms update their UI. CSS selectors will break. Build a fallback alert when a selector returns empty, so you know to update it
• Scraping more than once per day on 100+ URLs risks IP blocks. Playwright with a residential proxy service reduces this if daily isn’t frequent enough for your category
• Check each platform’s ToS. Viewing public product pages is generally fine; high-frequency automated access is a grey area, especially in flash-sale periods

Third-party costs

• Playwright MCP: free (open source)
• Residential proxy service (if needed): $10–30/month
• Google Sheets: free

What you’re building

Every Friday evening, OpenClaw messages each staff member on WhatsApp to collect their availability for the following week. On Sunday evening it generates the roster against your coverage rules and posts it to your staff WhatsApp group. When a staff member calls in sick, the agent contacts the next available substitute and confirms the shift automatically.

Reference skills

Install i-mw/cron-mastery to understand how to configure recurring cron jobs correctly in OpenClaw, and review 1kalin/afrexai-gym-fitness for scheduling logic patterns. No single skill covers this use case. You’re building it as a custom SKILL.md.

Components needed

• Google Sheets (staff roster, shift definitions, weekly availability responses)
• Google Sheets MCP (read/write access for the agent)
• WhatsApp Business API (already connected)
• Two cron jobs: Friday availability collection + Sunday roster generation
• A custom SKILL.md for availability parsing, roster generation, and sick-day substitution

Step 1: Create your staff roster in Google Sheets. Three tabs:

• Staff: name, WhatsApp number, roles, max hours/week, min rest hours
• Shifts: shift names and times, minimum coverage per role (weekday vs. weekend)
• Availability: auto-populated by the agent as responses arrive each week

Step 2: Install the Google Sheets MCP and grant read/write access to the roster file.

Step 3: Write the availability collection skill. This is a custom SKILL.md that: reads the Staff tab, sends a standardised availability request message to each staff member’s WhatsApp on Friday at 6pm, parses their responses (“available Mon–Thu”, “can’t do Wednesday”), and writes results to the Availability tab.

Step 4: Write the roster generation trigger with a Lobster approval gate. Enable Lobster in openclaw.json ("tools": { "alsoAllow": ["lobster"] }), then define a .lobster pipeline for the Sunday trigger: read Availability tab, generate roster, send you a WhatsApp preview with an approval: required gate, then broadcast to staff WhatsApp group on approval. This prevents a roster with missing coverage or an incorrect shift from going to the whole team before you’ve reviewed it.

Step 5: Write the sick-day substitution trigger. Define keywords in SOUL.md that flag a sick-day message (“MC”, “sick”, “cannot come”). When detected, the skill reads that day’s roster, identifies the open shift, and messages the next available staff member from the Availability tab. Once confirmed, it updates the roster in Sheets and notifies the manager.

Step 6: Use i-mw/cron-mastery as your cron setup reference. The Friday and Sunday crons are time-sensitive. This skill covers the correct patterns for reliable scheduled jobs in OpenClaw.

Step 7: Test the full cycle. Run the availability collection manually with 3–4 test numbers. Verify Sheets updates correctly. Generate a test roster and check coverage rules fire. Simulate a sick-day call-out and verify the substitution message goes to the right person.

Third-party costs

• Google Sheets: free
• WhatsApp Business API: ~$0.02–0.08 per staff member per week for the availability collection conversation. For a 10-person team: roughly $1–3/week