OpenClaw for freelancers: automating client work and invoicing end-to-end

If you bill by the hour and juggle half a dozen clients, the admin can swallow a day every week. OpenClaw—now at v1.18.4 and hosted on ClawCloud—lets a single agent handle the boring parts: incoming emails, meeting scheduling, time tracking, proposal drafts, and ultimately invoices that hit the client’s inbox before you remember it’s month-end. Below is the exact workflow I shipped for my consultancy. Copy, fork, or critique—it cut my overhead from ~8 hrs to ~90 min per week.

Why automate freelance admin with OpenClaw?

Typical stack for a solo dev:

Gmail + Slack + WhatsApp for client chatter
Harvest or Toggl for time tracking
Notion or Google Docs for proposals & status updates
QuickBooks, Stripe, or FreshBooks for invoicing

Four UIs, four sets of API tokens, and plenty of context switching. OpenClaw sits in the middle, calls those APIs through Composio integrations, and maintains a memory so the agent can answer “what did we do for Client X last Tuesday?” without you searching for it.

I looked at Zapier and Make.com first. They’re fine but run per-zap pricing and fall apart for natural-language queries like “Slack Bob a daily summary of billable time unless I’m AFK.” With OpenClaw I scripted that in client.js once and forgot about it.

Setting up OpenClaw on ClawCloud in 60 seconds

If you prefer self-host, node@22.2.0 and npm i -g openclaw still works. I moved to ClawCloud so the daemon survives my laptop closing.

Sign in at cloud.openclaw.ai
Click New Agent, name it client-bot-prod
Select the Freelancer recipe (pre-loads Harvest + QuickBooks actions)
Provision. Average cold start: 48 s

The dashboard spits out a public webhook URL and an SSH tunnel for local debugging:

ssh -L 3000:localhost:3000 client-bot-prod@clawcloud.run

All config lives in .clawrc.json. Example trimmed for clarity:

{
  "agent": "client-bot-prod",
  "memory": "s3://claw-mem-eu/2345234/",
  "tools": [
    "composio:google.gmail@v3",
    "composio:slack@v2",
    "composio:harvest@v1",
    "composio:quickbooks@v2"
  ],
  "schedule": "0 * * * *" // hourly check-in
}

Connecting communication channels: email, Slack, WhatsApp

OpenClaw’s gateway UI lets you paste OAuth tokens, but I prefer the CLI so everything is source-controlled. Run:

claw tool:add composio:google.gmail@v3 --scopes "gmail.readonly,gmail.send"
claw tool:add composio:slack@v2 --scopes "channels:read,chat:write"
claw tool:add composio:twilio.whatsapp@v1

You’ll be bounced to the respective OAuth consent screens. Tokens end up encrypted (AES-256) in ClawCloud’s vault—not in plain JSON. To verify:

claw tool:list --verbose

Now create a routing rule so any email labelled client/* gets mirrored to the agent’s memory and optionally Slack:

claw triggers:add --tool gmail --event "new_email:label=client/*" --action memory.store
claw triggers:add --tool gmail --event "new_email:label=client/*" --action slack.post

This alone saves 20 Slack copy-pastes per day.

Tracking time automatically with Harvest API

Manual timers are where freelancers bleed money. I wired the Harvest API so each Git commit, Slack call, or calendar event nudges the timer.

// file: timers.js
module.exports = async function (ctx) {
  if (ctx.event === "git.commit") {
    await ctx.tools.harvest.startTimer({
      project_id: matchProject(ctx.payload.repo),
      notes: ctx.payload.commit_msg
    })
  }
  if (ctx.event === "calendar.event.start" && ctx.payload.summary.includes("Client")) {
    await ctx.tools.harvest.startTimer({
      project_id: matchProject(ctx.payload.summary),
      notes: ctx.payload.summary
    })
  }
}

Trade-off: Harvest rate-limits at 1000 API calls per hour. With frequent commits you can hit that. I added debounce: 300 in the trigger config to batch events.

Every midnight the agent calls:

ctx.tools.harvest.dailyReport({ date: ctx.now })

and posts a DM to me on Slack. If total billable < 6 hrs I know to either work or adjust retainers.

Generating proposals and status updates with templates + memory

Clients love a tidy PDF. I keep Markdown templates in Git:

templates/
  proposal.md
  status-weekly.md
  invoice-cover.md

The agent fills tokens like {{client_name}} or {{hours}} using its memory + Harvest data, then converts to PDF via pandoc (yes, OpenClaw can shell out). Example:

// proposal.js
module.exports = async function (ctx) {
  const data = {
    client_name: ctx.params.client,
    scope: ctx.params.scope,
    rate: 150,
    timeline: "2 weeks"
  }
  await ctx.shell.exec(`mustache '${JSON.stringify(data)}' templates/proposal.md | pandoc -o /tmp/proposal.pdf`)
  await ctx.tools.gmail.send({
    to: ctx.params.email,
    subject: `Proposal for ${data.client_name}`,
    attachments: ["/tmp/proposal.pdf"]
  })
}

Gotcha: Shell access is sandboxed to 60 s CPU and 256 MB RAM on ClawCloud’s shared tier. Heavy LaTeX is a no-go—stick to Markdown + Pandoc defaults.

Invoicing clients via QuickBooks or Stripe with Composio actions

When the month flips, the agent:

Grabs unbilled Harvest entries
Groups by client
Creates draft invoices in QuickBooks
Sends a PDF copy via email + Slack DM to the client

Core snippet:

// invoice.js
module.exports = async function (ctx) {
  const entries = await ctx.tools.harvest.unbilled({ since: ctx.startOfLastMonth })
  const grouped = groupBy(entries, "client_id")
  for (const [clientId, lines] of Object.entries(grouped)) {
    const qbInvoice = await ctx.tools.quickbooks.createInvoice({
      customer_id: clientId,
      line_items: lines.map(l => ({
        description: l.notes,
        hours: l.hours,
        rate: 150
      }))
    })
    await ctx.tools.gmail.send({
      to: lines[0].client_email,
      subject: `Invoice ${qbInvoice.id} – ${ctx.formatDate('YYYY-MM')}`,
      attachments: [qbInvoice.pdf_url]
    })
  }
}

Stripe users can swap quickbooks.createInvoice for stripe.invoice.create; Composio ships both.

Edge case: If a client requires PO numbers, add a custom field. QuickBooks API allows it; Stripe does not, so you’ll need to embed PO in the description.

Orchestrating the multi-client workflow in one agent

The last piece is routing context so the agent doesn’t spill AliceCorp details into BobLLC’s inbox. I use workspaces:

// .clawrc excerpt
"routing": {
  "gmail:client/alicecorp": "ws-alicecorp",
  "slack:alicecorp": "ws-alicecorp",
  "gmail:client/bobllc": "ws-bobllc"
}

Each workspace has its own vector store; the agent loads only what’s relevant before responding. Memory separation costs ~120 ms per call (extra DB round-trip) but is worth avoiding NDAs being nuked.

I also pinned client-specific slash commands in Slack:

/hours this-week → Harvest summary
/invoice preview → Generates but does not send
/proposal new-feature-x → Drafts proposal using the template

All backed by the same agent; context comes from the channel ID.

Caveats, rate limits, what still needs manual eyes

Harvest: 1000 req/hr. Batch your timers or pay for the higher tier.
QuickBooks: Sandbox often 500s on weekends. Retry logic is mandatory.
Email threading: Gmail API sometimes mis-threads when the References header is missing. Add it.
Legal review: I never let the agent send contracts without me skimming the PDF. Liability is on you, not the bot.
Privacy: OpenClaw memory is encrypted but if you need GDPR compliance, host your own Postgres + S3 in the EU region.

Despite those rough edges the ROI is immediate: I shipped v0 Monday, invoiced three clients Wednesday, and by Friday my admin load was down 80%. Next step? Add GPT-4o for summarizing daily stand-ups so I don’t have to attend half of them.

If you try the setup, ping the #freelance-workflow thread on GitHub Discussions—curious what breaks on your stack and what you automate next.