# OpenClawBot (`happitap/openclawbot`) Actor

Your own personal AI assistant running in the cloud. No server setup, no maintenance — just deploy and go. Runs a full OpenClaw instance as a dedicated container. It provides the complete OpenClaw experience — AI agent, multi-channel messaging, browser control, skills, persistent memory

- **URL**: https://apify.com/happitap/openclawbot.md
- **Developed by:** [HappiTap](https://apify.com/happitap) (community)
- **Categories:** Automation, Integrations, Other
- **Stats:** 20 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## OpenClawBot - OpenClaw-as-a-Service

**Your own personal AI assistant running in the cloud. No server setup, no maintenance — just deploy and go.**

OpenClawBot is an Apify Actor that runs a **full OpenClaw instance** as a dedicated container. It provides the complete OpenClaw experience — AI agent, multi-channel messaging, browser control, skills, persistent memory — all accessible via a simple HTTP API.

Think of it as a **managed OpenClaw server**: instead of buying a Mac Mini or renting a VPS to run OpenClaw, you deploy this actor and get a fully functional OpenClaw instance that scales to zero when idle and wakes up on demand.

### What is OpenClaw?

[OpenClaw](https://openclaw.ai) is an open-source personal AI assistant you normally self-host. It features:

- **AI Agent** powered by Anthropic Claude, OpenAI, or local models
- **Multi-channel inbox** — WhatsApp, Telegram, Discord, Slack, Signal, iMessage, Microsoft Teams, Matrix, and more
- **Browser control** — browse the web, fill forms, extract data
- **Full system access** — run commands, read/write files (sandboxed in container)
- **Skills & plugins** — extend with community skills from [ClawHub](https://clawhub.com)
- **Persistent memory** — remembers context across conversations

This actor packages all of that into a cloud-hosted container with an HTTP API on top.

### What OpenClawBot Provides

- **Full OpenClaw Gateway** — The WebSocket control plane runs inside the container
- **AI Agent endpoint** — Talk to the AI agent via `POST /agent`
- **12+ messaging channels** — WhatsApp, Telegram, Discord, Slack, Signal, iMessage, MS Teams, Matrix, Google Chat, Zalo, WebChat
- **Skills management** — Install, list, and remove skills via API
- **Configuration API** — Get/set any OpenClaw config remotely
- **Diagnostics** — Run `openclaw doctor` via API
- **Dashboard proxy** — Access OpenClaw's Control UI and WebChat through the actor URL
- **Browser control** — Chromium pre-installed for OpenClaw's browser tool
- **Persistent profile** — Sessions, config, memory, and skills survive container restarts via Apify KV Store
- **Auto-restart** — Gateway auto-restarts on crash (up to 5 attempts)
- **Idle shutdown** — Shuts down after configurable idle period to save costs

### Quick Start

#### 1. Deploy to Apify

Deploy this Actor to your Apify account and enable **Standby mode**.

#### 2. Configure the Actor Input

When you run the actor, fill in these fields in the **Input** tab:

| Input Field | Description | Required |
|-------------|-------------|----------|
| `apiKey` | A **password you make up** to protect POST endpoints (any strong random string). Encrypted automatically. | Recommended |
| `anthropicApiKey` | Anthropic API key for Claude models ([get one here](https://console.anthropic.com/)) | Yes (or OpenAI) |
| `openaiApiKey` | OpenAI API key for GPT models ([get one here](https://platform.openai.com/)) | Yes (or Anthropic) |

All secret fields are **encrypted** by Apify — they won't appear in logs or be visible after saving.

> **Note:** `apiKey` is NOT an OpenClaw key — it's a password **you choose** to add an extra auth layer on top of Apify's platform token. If you don't want it, uncheck `requireApiKey` in the input.

#### 3. Start the Actor

Run the Actor with Standby mode enabled. On startup it will:

1. Restore saved OpenClaw profile from KV Store
2. Verify the OpenClaw CLI
3. Start the OpenClaw Gateway (port 18789)
4. Start the HTTP API server
5. Begin periodic profile saving

#### 4. Call the API

**Authentication:** Pass your Apify API token as a query parameter: `?token=YOUR_APIFY_TOKEN`

You can find your token in Apify Console → Settings → API Tokens.

```bash
## Health check
curl "https://happitap--openclawbot.apify.actor/health?token=YOUR_APIFY_TOKEN"

## Talk to the AI agent
curl -X POST "https://happitap--openclawbot.apify.actor/agent?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"message": "What can you do?"}'

## Send a Telegram message
curl -X POST "https://happitap--openclawbot.apify.actor/send?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channel": "telegram", "target": "@username", "message": "Hello!"}'
````

> Your Standby URL base is `https://happitap--openclawbot.apify.actor`

### Standby Mode & Cold Starts

| State | Response Time | What Happens |
|-------|--------------|--------------|
| **Running** | ~100-500ms | Instant response |
| **Cold Start** | 20-40 seconds | Container boots, gateway starts, profile restores |
| **After Idle** | Actor shuts down | Next request triggers cold start |

The idle timeout defaults to **3 minutes** and is configurable via `idleTimeoutSec`. Set to `0` to disable auto-shutdown.

**Keep-Alive:** To avoid cold starts, ping `/health` every 2 minutes:

```bash
*/2 * * * * curl -s "https://happitap--openclawbot.apify.actor/health?token=YOUR_APIFY_TOKEN" > /dev/null
```

### API Endpoints

#### Core

##### `GET /health`

Health check — returns gateway status and uptime.

```json
{
  "ok": true,
  "gateway": { "host": "127.0.0.1", "port": 18789, "reachable": true },
  "uptimeSec": 12345
}
```

##### `GET /status`

Full OpenClaw status (runs `openclaw status --all`).

```json
{ "ok": true, "statusText": "..." }
```

#### AI Agent

##### `POST /agent`

Send a message to the AI agent and get a response.

**Request:**

```json
{
  "message": "Summarize my unread emails",
  "thinking": "medium",
  "channel": "telegram",
  "target": "@myuser",
  "account": "default"
}
```

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `message` | string | Yes | The message to send to the agent |
| `thinking` | string | No | Thinking level: `none`, `low`, `medium`, `high` (default: `medium`) |
| `channel` | string | No | Optionally deliver the reply to a channel |
| `target` | string | No | Target for channel delivery |
| `account` | string | No | OpenClaw account (default: `default`) |

**Response:**

```json
{
  "ok": true,
  "reply": "Here's a summary of your unread emails...",
  "exitCode": 0
}
```

#### Messaging

##### `POST /send`

Send a text message to any supported channel.

**Request:**

```json
{
  "channel": "whatsapp",
  "target": "+919876543210",
  "message": "Hello from OpenClawBot!",
  "account": "default",
  "options": { "replyTo": null, "threadId": null }
}
```

**Supported channels and target formats:**

| Channel | Target Format | Example |
|---------|--------------|---------|
| `whatsapp` | E.164 phone number | `+919876543210` |
| `telegram` | @username or chat ID | `@johndoe` or `-1001234567890` |
| `discord` | Channel/User ID | `123456789012345678` |
| `slack` | Channel name or ID | `#general` or `C01234ABCDE` |
| `signal` | Phone number | `+15551234567` |
| `imessage` | Phone/email | `+15551234567` |
| `msteams` | Channel ID | (Teams channel ID) |
| `matrix` | Room ID | `!roomid:server.com` |
| `googlechat` | Space ID | (Google Chat space) |
| `webchat` | Session ID | (WebChat session) |

**Response:**

```json
{
  "ok": true,
  "channel": "telegram",
  "target": "@johndoe",
  "sentAt": "2026-02-12T13:30:00.000Z",
  "exitCode": 0,
  "stdout": "...",
  "stderr": ""
}
```

#### Channel Management

##### `GET /channels`

List all supported channels and their connection status.

```json
{
  "ok": true,
  "supportedChannels": ["whatsapp", "telegram", "discord", "slack", "signal", "..."],
  "statusText": "...",
  "gateway": { "running": true, "port": 18789, "uptimeSec": 300 }
}
```

##### `POST /channels/pair`

Pair/connect any channel.

**Request:**

```json
{
  "channel": "whatsapp",
  "account": "default",
  "config": {}
}
```

##### `POST /channels/configure`

Configure a channel with credentials.

**Request:**

```json
{
  "channel": "telegram",
  "account": "default",
  "config": { "bot-token": "123456:ABC-DEF..." }
}
```

##### `POST /whatsapp/pair` *(legacy)*

WhatsApp-specific pairing with QR code support.

**Request:**

```json
{ "format": "auto", "account": "default" }
```

**Response:**

```json
{
  "ok": true,
  "account": "default",
  "pairing": { "code": "ABCD-EFGH", "qrText": "..." },
  "qrPngBase64": "iVBORw0KGgo..."
}
```

#### Skills

##### `GET /skills`

List installed skills.

##### `POST /skills/install`

Install a skill from ClawHub or a URL.

**Request:**

```json
{ "name": "weather", "source": "clawhub" }
```

##### `POST /skills/remove`

Remove an installed skill.

**Request:**

```json
{ "name": "weather" }
```

#### Configuration

##### `GET /config`

Get OpenClaw configuration. Optionally filter by key: `GET /config?key=model.provider`.

##### `POST /config`

Set a configuration value.

**Request:**

```json
{ "key": "model.provider", "value": "anthropic" }
```

#### Diagnostics

##### `GET /doctor`

Run `openclaw doctor` — checks configuration, channel health, and surfaces issues.

```json
{
  "ok": true,
  "report": "...",
  "issues": ["..."],
  "exitCode": 0
}
```

#### Dashboard & WebChat

##### `GET /dashboard/*`

Proxies requests to OpenClaw's built-in Control UI. Access the full dashboard at:

```
https://happitap--openclawbot.apify.actor/dashboard?token=YOUR_APIFY_TOKEN
```

##### `GET /webchat/*`

Proxies requests to OpenClaw's WebChat interface.

### Input Configuration

#### Required

| Field | Type | Description |
|-------|------|-------------|
| `mode` | string | `"standby"` for HTTP API server |
| `profileStoreKey` | string | KV key for profile archive (default: `"OPENCLAW_PROFILE_TAR_GZ"`) |

#### AI Model Settings

| Field | Type | Description |
|-------|------|-------------|
| `anthropicApiKey` | string | Anthropic API key (or use `ANTHROPIC_API_KEY` secret) |
| `openaiApiKey` | string | OpenAI API key (or use `OPENAI_API_KEY` secret) |
| `modelProvider` | string | Provider: `anthropic`, `openai`, `openrouter`, etc. |
| `modelName` | string | Model name: `claude-sonnet-4-20250514`, `gpt-4o`, etc. |

#### Gateway & Server

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `gatewayPort` | number | `18789` | OpenClaw gateway port |
| `gatewayHost` | string | `"127.0.0.1"` | Gateway host binding |
| `gatewayVerbose` | boolean | `false` | Verbose gateway logging |
| `idleTimeoutSec` | number | `180` | Idle shutdown timeout (0 = never) |
| `enableDashboardProxy` | boolean | `true` | Expose /dashboard and /webchat |

#### Profile & Security

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `persistProfile` | boolean | `true` | Save profile to KV store |
| `profileSaveIntervalSec` | number | `60` | Save interval in seconds |
| `enableLocks` | boolean | `true` | Per-channel mutex locks |
| `allowlistChannels` | array | `["whatsapp","telegram","discord","slack","signal"]` | Allowed channels |
| `maxMessageLength` | number | `4000` | Max message length |

### Pricing (Pay-Per-Event)

| Event | Price | Rate |
|-------|-------|------|
| `agent-request` | $0.005 | $5 per 1,000 agent requests |
| `whatsapp-message-sent` | $0.0015 | $1.50 per 1,000 messages |
| `telegram-message-sent` | $0.0008 | $0.80 per 1,000 messages |
| `discord-message-sent` | $0.0008 | $0.80 per 1,000 messages |
| `slack-message-sent` | $0.0008 | $0.80 per 1,000 messages |
| `signal-message-sent` | $0.0008 | $0.80 per 1,000 messages |
| `channel-pair` | $0.005 | $5 per 1,000 pairings |
| `skill-install` | $0.001 | $1 per 1,000 installs |
| `profile-save` | $0.0001 | $0.10 per 1,000 saves |
| `status-check` | $0.0001 | $0.10 per 1,000 checks |

### Security

- **Apify Platform Auth** — All requests require Apify API token (`?token=`)
- **Localhost Gateway** — OpenClaw gateway binds to `127.0.0.1` only
- **No Secret Logging** — Bot tokens, phone numbers, and session data are redacted from logs
- **Profile Persistence** — Stored in private Apify Key-Value Store
- **Sandboxed Execution** — Runs inside an isolated Docker container

### Architecture

```
┌──────────────────────────────────────────────────────────────────┐
│                        Apify Container                           │
│                                                                  │
│  ┌──────────────────┐     ┌────────────────────────────────┐    │
│  │   Express API    │     │     OpenClaw Gateway           │    │
│  │  (Standby Port)  │────►│  ws://127.0.0.1:18789          │    │
│  │                  │     │  - Control plane                │    │
│  │  /health         │     │  - Channel connections          │    │
│  │  /agent          │     │  - Session management           │    │
│  │  /send           │     │  - WebChat & Dashboard UI       │    │
│  │  /channels/*     │     └──────────┬─────────────────────┘    │
│  │  /skills/*       │                │                          │
│  │  /config         │     ┌──────────▼─────────────────────┐    │
│  │  /doctor         │     │     OpenClaw CLI + Agent        │    │
│  │  /dashboard/*    │     │  - AI reasoning (Claude/GPT)    │    │
│  │  /webchat/*      │     │  - Browser control (Chromium)   │    │
│  └────────┬─────────┘     │  - Skills execution             │    │
│           │               │  - File system access           │    │
│           ▼               └──────────┬─────────────────────┘    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │              Apify Key-Value Store                       │    │
│  │     (Profile: sessions, config, memory, skills)          │    │
│  └─────────────────────────────────────────────────────────┘    │
└──────────────────────────────────────────────────────────────────┘
                              │
                              ▼
  ┌────────────────────────────────────────────────────────────┐
  │                   External Services                        │
  │                                                            │
  │  WhatsApp │ Telegram │ Discord │ Slack │ Signal │ iMessage │
  │  MS Teams │ Matrix │ Google Chat │ Zalo │ WebChat          │
  │                                                            │
  │  Anthropic (Claude) │ OpenAI (GPT) │ Local Models          │
  └────────────────────────────────────────────────────────────┘
```

### Error Codes

| Code | Description |
|------|-------------|
| `INVALID_CHANNEL` | Channel not supported or not in allowlist |
| `INVALID_TARGET` | Target format doesn't match channel requirements |
| `INVALID_MESSAGE` | Message empty or too long |
| `INVALID_REQUEST` | Missing required fields |
| `NOT_PAIRED` | Channel not paired (use `/channels/pair` first) |
| `GATEWAY_DOWN` | OpenClaw gateway not reachable |
| `GATEWAY_STARTING` | Gateway is still starting up |
| `AGENT_ERROR` | AI agent failed to process the request |
| `OPENCLAW_ERROR` | Error from OpenClaw CLI |
| `SKILL_NOT_FOUND` | Requested skill not found |
| `CONFIG_ERROR` | Configuration error |
| `INTERNAL_ERROR` | Unexpected server error |

### Troubleshooting

#### Gateway won't start

- Minimum **2GB memory** recommended (4GB+ for browser control)
- Check logs for gateway startup errors
- Run `GET /doctor` to diagnose issues

#### Agent not responding

- Ensure `ANTHROPIC_API_KEY` or `OPENAI_API_KEY` is set
- Check model provider configuration via `GET /config?key=model`
- Agent requests have a 2-minute timeout

#### Channel pairing issues

- Use `POST /channels/pair` with the correct channel name
- For WhatsApp, use `POST /whatsapp/pair` for QR code support
- Ensure `persistProfile` is `true` so pairing survives restarts
- Profile saves every 60s by default and immediately after pairing

#### Messages not sending

- Verify target format matches channel requirements
- Check channel is paired: `GET /channels`
- For Telegram/Discord, ensure bot tokens are configured via `/channels/configure`

#### Cold start too slow

- Use keep-alive pings every 2 minutes
- Increase `idleTimeoutSec` to keep the actor running longer
- Set `idleTimeoutSec: 0` to disable auto-shutdown entirely

### Reference Documentation

- [OpenClaw Documentation](https://docs.openclaw.ai)
- [OpenClaw GitHub](https://github.com/openclaw/openclaw)
- [OpenClaw Getting Started](https://docs.openclaw.ai/getting-started)
- [ClawHub Skills](https://clawhub.com)
- [Apify Standby Mode](https://docs.apify.com/platform/actors/running/standby)
- [Apify Key-Value Store](https://docs.apify.com/platform/storage/key-value-store)

***

**License**: Apache-2.0 | **Version**: 2.0.0

# Actor input Schema

## `mode` (type: `string`):

Actor operation mode: 'standby' for HTTP API server, 'batch' for single operation

## `profileStoreKey` (type: `string`):

Key-Value Store key name to store OpenClaw profile archive (e.g., tar.gz of ~/.openclaw)

## `anthropicApiKey` (type: `string`):

Anthropic API key for Claude models. Can also be set via ANTHROPIC\_API\_KEY secret.

## `openaiApiKey` (type: `string`):

OpenAI API key for GPT models. Can also be set via OPENAI\_API\_KEY secret.

## `modelProvider` (type: `string`):

AI model provider to use (e.g., anthropic, openai, openrouter)

## `modelName` (type: `string`):

Specific model name (e.g., claude-sonnet-4-20250514, gpt-4o)

## `gatewayPort` (type: `integer`):

OpenClaw gateway port (default: 18789)

## `gatewayHost` (type: `string`):

OpenClaw gateway host binding (default: 127.0.0.1)

## `gatewayVerbose` (type: `boolean`):

Enable verbose gateway logging (WARNING: may log sensitive data)

## `persistProfile` (type: `boolean`):

Save OpenClaw profile to Key-Value Store after operations

## `profileSaveIntervalSec` (type: `integer`):

How often to save profile in Standby mode (seconds)

## `enableLocks` (type: `boolean`):

Enable per-channel mutex to prevent concurrent operations

## `allowlistChannels` (type: `array`):

List of allowed messaging channels (whatsapp, telegram, discord, slack, signal, imessage, bluebubbles, msteams, matrix, googlechat, zalo, webchat)

## `maxMessageLength` (type: `integer`):

Maximum message length in characters

## `enableDashboardProxy` (type: `boolean`):

Expose OpenClaw Control UI and WebChat via /dashboard and /webchat endpoints

## `idleTimeoutSec` (type: `integer`):

Shut down actor after this many seconds of inactivity (0 = never)

## Actor input object example

```json
{
  "mode": "standby",
  "profileStoreKey": "OPENCLAW_PROFILE_TAR_GZ",
  "gatewayPort": 18789,
  "gatewayHost": "127.0.0.1",
  "gatewayVerbose": false,
  "persistProfile": true,
  "profileSaveIntervalSec": 60,
  "enableLocks": true,
  "allowlistChannels": [
    "whatsapp",
    "telegram",
    "discord",
    "slack",
    "signal"
  ],
  "maxMessageLength": 4000,
  "enableDashboardProxy": true,
  "idleTimeoutSec": 180
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing logs of messages sent and operations performed via the Clawbot API

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "standby",
    "profileStoreKey": "OPENCLAW_PROFILE_TAR_GZ",
    "gatewayPort": 18789,
    "gatewayHost": "127.0.0.1",
    "gatewayVerbose": false,
    "persistProfile": true,
    "profileSaveIntervalSec": 60,
    "enableLocks": true,
    "allowlistChannels": [
        "whatsapp",
        "telegram",
        "discord",
        "slack",
        "signal"
    ],
    "maxMessageLength": 4000,
    "enableDashboardProxy": true,
    "idleTimeoutSec": 180
};

// Run the Actor and wait for it to finish
const run = await client.actor("happitap/openclawbot").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "standby",
    "profileStoreKey": "OPENCLAW_PROFILE_TAR_GZ",
    "gatewayPort": 18789,
    "gatewayHost": "127.0.0.1",
    "gatewayVerbose": False,
    "persistProfile": True,
    "profileSaveIntervalSec": 60,
    "enableLocks": True,
    "allowlistChannels": [
        "whatsapp",
        "telegram",
        "discord",
        "slack",
        "signal",
    ],
    "maxMessageLength": 4000,
    "enableDashboardProxy": True,
    "idleTimeoutSec": 180,
}

# Run the Actor and wait for it to finish
run = client.actor("happitap/openclawbot").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "standby",
  "profileStoreKey": "OPENCLAW_PROFILE_TAR_GZ",
  "gatewayPort": 18789,
  "gatewayHost": "127.0.0.1",
  "gatewayVerbose": false,
  "persistProfile": true,
  "profileSaveIntervalSec": 60,
  "enableLocks": true,
  "allowlistChannels": [
    "whatsapp",
    "telegram",
    "discord",
    "slack",
    "signal"
  ],
  "maxMessageLength": 4000,
  "enableDashboardProxy": true,
  "idleTimeoutSec": 180
}' |
apify call happitap/openclawbot --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=happitap/openclawbot",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenClawBot",
        "description": "Your own personal AI assistant running in the cloud. No server setup, no maintenance — just deploy and go. Runs a full OpenClaw instance as a dedicated container. It provides the complete OpenClaw experience — AI agent, multi-channel messaging, browser control, skills, persistent memory",
        "version": "0.0",
        "x-build-id": "EDyNEXlNW52a9U26D"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/happitap~openclawbot/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-happitap-openclawbot",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/happitap~openclawbot/runs": {
            "post": {
                "operationId": "runs-sync-happitap-openclawbot",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/happitap~openclawbot/run-sync": {
            "post": {
                "operationId": "run-sync-happitap-openclawbot",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode",
                    "profileStoreKey"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "standby",
                            "batch"
                        ],
                        "type": "string",
                        "description": "Actor operation mode: 'standby' for HTTP API server, 'batch' for single operation",
                        "default": "standby"
                    },
                    "profileStoreKey": {
                        "title": "Profile Store Key",
                        "type": "string",
                        "description": "Key-Value Store key name to store OpenClaw profile archive (e.g., tar.gz of ~/.openclaw)",
                        "default": "OPENCLAW_PROFILE_TAR_GZ"
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API Key",
                        "type": "string",
                        "description": "Anthropic API key for Claude models. Can also be set via ANTHROPIC_API_KEY secret."
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API Key",
                        "type": "string",
                        "description": "OpenAI API key for GPT models. Can also be set via OPENAI_API_KEY secret."
                    },
                    "modelProvider": {
                        "title": "Model Provider",
                        "type": "string",
                        "description": "AI model provider to use (e.g., anthropic, openai, openrouter)"
                    },
                    "modelName": {
                        "title": "Model Name",
                        "type": "string",
                        "description": "Specific model name (e.g., claude-sonnet-4-20250514, gpt-4o)"
                    },
                    "gatewayPort": {
                        "title": "Gateway Port",
                        "minimum": 1024,
                        "maximum": 65535,
                        "type": "integer",
                        "description": "OpenClaw gateway port (default: 18789)",
                        "default": 18789
                    },
                    "gatewayHost": {
                        "title": "Gateway Host",
                        "type": "string",
                        "description": "OpenClaw gateway host binding (default: 127.0.0.1)",
                        "default": "127.0.0.1"
                    },
                    "gatewayVerbose": {
                        "title": "Gateway Verbose Logging",
                        "type": "boolean",
                        "description": "Enable verbose gateway logging (WARNING: may log sensitive data)",
                        "default": false
                    },
                    "persistProfile": {
                        "title": "Persist Profile",
                        "type": "boolean",
                        "description": "Save OpenClaw profile to Key-Value Store after operations",
                        "default": true
                    },
                    "profileSaveIntervalSec": {
                        "title": "Profile Save Interval (seconds)",
                        "minimum": 10,
                        "maximum": 3600,
                        "type": "integer",
                        "description": "How often to save profile in Standby mode (seconds)",
                        "default": 60
                    },
                    "enableLocks": {
                        "title": "Enable Channel Locks",
                        "type": "boolean",
                        "description": "Enable per-channel mutex to prevent concurrent operations",
                        "default": true
                    },
                    "allowlistChannels": {
                        "title": "Allowed Channels",
                        "type": "array",
                        "description": "List of allowed messaging channels (whatsapp, telegram, discord, slack, signal, imessage, bluebubbles, msteams, matrix, googlechat, zalo, webchat)",
                        "default": [
                            "whatsapp",
                            "telegram",
                            "discord",
                            "slack",
                            "signal"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxMessageLength": {
                        "title": "Max Message Length",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum message length in characters",
                        "default": 4000
                    },
                    "enableDashboardProxy": {
                        "title": "Enable Dashboard Proxy",
                        "type": "boolean",
                        "description": "Expose OpenClaw Control UI and WebChat via /dashboard and /webchat endpoints",
                        "default": true
                    },
                    "idleTimeoutSec": {
                        "title": "Idle Timeout (seconds)",
                        "minimum": 0,
                        "maximum": 86400,
                        "type": "integer",
                        "description": "Shut down actor after this many seconds of inactivity (0 = never)",
                        "default": 180
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```