How to Add iMessage to OpenClaw Without a Mac

Claw Messenger is a managed relay that connects any AI agent to iMessage, RCS, and SMS without requiring macOS or Apple hardware. It works with OpenClaw, n8n, LangChain, or any custom agent via WebSocket or REST API. Setup takes about five minutes. Plans start at $5/mo for 1,000 messages.

We built this because the default OpenClaw iMessage path has a dependency most people can't satisfy.

---

Why does OpenClaw iMessage require a Mac?

The built-in integration uses BlueBubbles, which reads the iMessage database stored locally on macOS. That database only exists on Apple hardware. So if you want your OpenClaw agent to send and receive iMessages, the official path is: buy or rent a Mac, leave it running 24/7, grant Full Disk Access, and maintain it.

That's fine if you already own a Mac. Most people deploying OpenClaw in production don't. They run their agents on Linux VPSes, in Docker containers, on cloud VMs. The Mac is an infrastructure dependency for a single messaging channel, and it was blocking adoption.

We kept hearing the same question in the OpenClaw community: how do I add iMessage to my agent on Linux? The answer was always "you can't, unless you get a Mac." We wanted a different answer.

How to set up OpenClaw iMessage on Linux or Docker

Install the Claw Messenger plugin:

openclaw plugins install @emotion-machine/claw-messenger

Create an account at clawmessenger.com and copy your API key from the dashboard.

Add the channel block to ~/.openclaw/openclaw.json:

{
  "channels": {
    "claw-messenger": {
      "apiKey": "cm_your_key_here",
      "serverUrl": "wss://relay.clawmessenger.com"
    }
  }
}

Restart the gateway:

openclaw gateway restart

Register the phone numbers you want to allow in the Claw Messenger dashboard. Only registered numbers can reach your agent. This is a security default, not a limitation. Open inbound from any number is a spam vector we decided to block from day one.

Text your agent's Claw Messenger number from your iPhone. You should get a reply back over iMessage.

No Xcode. No Full Disk Access. No Mac.

How does Claw Messenger route iMessage without macOS?

Your OpenClaw gateway opens a persistent WebSocket to wss://relay.clawmessenger.com. When someone texts your agent's number, the carrier delivers the message to our relay infrastructure. We forward it to your gateway over the WebSocket. Your agent processes it. The reply goes back the same way.

Three things worth knowing about the architecture:

Message content is not stored on our relay servers. The WebSocket is TLS-encrypted. And protocol selection (iMessage vs. RCS vs. SMS) happens automatically at the carrier level based on the recipient's device. You configure one channel; we handle the routing.

For agents that do anything beyond basic Q&A, add HMAC webhook verification:

{
  "channels": {
    "claw-messenger": {
      "apiKey": "cm_...",
      "serverUrl": "wss://relay.clawmessenger.com",
      "webhookSecret": "whsec_..."
    }
  }
}

We sign every inbound payload. Your gateway verifies the signature before processing. This prevents spoofed messages from reaching your agent's logic.

What iMessage features work with OpenClaw agents?

We built Claw Messenger expecting people to use it for text Q&A. What actually happened was more interesting. People started using native iMessage features as agent inputs.

Tapbacks as confirmations. One early user set up thumbs-up to approve calendar entries and thumbs-down to reject them. No typing, just a long-press reaction. We hadn't designed tapbacks as an input mechanism, but the interaction cost is so low that it works better than "reply YES to confirm" patterns. Your agent receives tapback events with the reaction type and the referenced message.

Typing indicators change perception. When the agent sends a typing bubble before responding, the conversation reads like texting a person. Without it, replies appear out of nothing and the experience feels mechanical. We made typing indicators a single function call because we found the difference matters more than the feature sounds.

Automatic RCS and SMS fallback. Your agent's contacts aren't all on iPhones. When a non-Apple device texts the agent, the system falls back to RCS where supported, then SMS. You don't configure this. One number, three protocols.

Read receipts signal processing. The agent can mark messages as read, which tells the sender their message was received and is being handled. Useful when your agent takes a few seconds to process a complex request.

Claw Messenger vs BlueBubbles for OpenClaw

BlueBubbles is open source and free. If you have a Mac you can dedicate to this, it's a reasonable option and we're not trying to replace it. Here's how the two approaches compare:

	BlueBubbles	Claw Messenger
Requires macOS	Yes, running 24/7	No
Cost	Free (you supply the Mac)	$5/mo for 1,000 messages
Setup time	30–60 minutes	~5 minutes
Maintenance	You manage the Mac	Managed relay service
Linux / Docker / VPS	Not supported	Fully supported
RCS + SMS fallback	No	Automatic
Tapbacks + typing indicators	Yes	Yes
HMAC webhook verification	No	Yes

Choose BlueBubbles if you already own a Mac, want zero monthly cost, and are comfortable maintaining the hardware. It's a solid open-source project.

Choose Claw Messenger if your OpenClaw agent runs on Linux, a VPS, or in Docker and you don't want to add Apple hardware to your stack. That's the specific gap we built this to fill.

Does Claw Messenger work with AI agents other than OpenClaw?

Yes. The OpenClaw plugin is one integration, but the underlying relay is a WebSocket and REST API that works with any agent framework. We've seen people connect agents built with n8n, LangChain, LangGraph, and custom Python/TypeScript/Go setups.

The general pattern looks like this:

import asyncio
import websockets
import json

async def imessage_loop(api_key, handle_message):
    uri = f"wss://relay.clawmessenger.com?key={api_key}"
    async with websockets.connect(uri) as ws:
        while True:
            raw = await ws.recv()
            message = json.loads(raw)
            reply = await handle_message(message)
            await ws.send(json.dumps({
                "to": message["from"],
                "text": reply
            }))

Your handle_message function is where the agent lives. It can be a LangChain agent's invoke(), an n8n workflow, a LangGraph stateful graph, or plain if/else logic. Claw Messenger is just the transport layer. It doesn't care what generates the reply.

For serverless or webhook-based agents, there's also a REST API. Receive messages via HMAC-verified webhook POST, send replies with a simple HTTP call. No persistent WebSocket needed.

The message format is minimal JSON:

{
  "from": "[phone]",
  "text": "Hey, what's the weather like tomorrow?",
  "timestamp": "2026-04-02T14:30:00Z",
  "type": "imessage"
}

More on the iMessage bot integration in our docs.

Who builds Claw Messenger?

Emotion Machine is a conversational AI company working on how AI converses and builds relationships, from voice models to conversational products to agent plugins. We're based in San Francisco.

Claw Messenger is on the agent plugin layer of that stack. We build Personality Machine (AI character infrastructure with persistent memory and behavioral state), domain-specific speech-to-speech voice models, and Dialog Machine (an AI phone agent that calls real people). Claw Messenger came out of realizing that AI agents need messaging channels that don't depend on specific hardware. iMessage was the first one we tackled.

If you hit issues, the setup guide covers edge cases and the troubleshooting page has fixes for connection drops, delivery failures, and registration problems. Or reach us at [e-mail].