# 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:** 22 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,happitap/openclawbot"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/b67MhgTU3g3trOBfI/builds/CtPRCc44orwGvt7iZ/openapi.json