---
title: "Call or Text Your OpenClaw AI bot using Vonage APIs (unofficial guide)"
url: "https://www.pardel.dev/2026/02/21/openclaw"
date: 2026-02-21
author: "Paul Ardeleanu"
tags: ["AI","OpenClaw","Vonage","Voice","SMS","Conversational-AI","JavaScript"]
description: "How to call or text your OpenClaw AI bot using Vonage APIs. This guide is unofficial and based on my experience with these technologies."
---

# Call or Text Your OpenClaw AI bot using Vonage APIs (unofficial guide)

What if your OpenClaw bot was as reachable as a friend? No app, no browser, just pick up the phone and call, or send a quick text and get a reply.

With the [Vonage Unofficial](https://github.com/pardel/vonage-unofficial-skill) skill for OpenClaw, any phone becomes an interface to your bot. Call a number and have a spoken conversation, or send an SMS and get a thoughtful reply within seconds. It works on every phone, everywhere, and it's all handled by a single server.

## Why Voice and SMS?

In a world of apps and chat platforms, phone calls and texts might seem old-school. But they have unique advantages:

- **Works on every phone**:  no smartphone required
- **No app installation**:  zero friction
- **Works without internet**:  great for spotty coverage areas (SMS)
- **Hands-free**:  talk while driving, cooking, or away from a screen (voice)
- **Universal**:  everyone knows how to make a call or send a text

Voice is great for longer interactions, dictating notes, or when you simply can't type. SMS is perfect for quick questions, reminders, or getting a brief answer when you don't want to open a screen. Together, they cover almost every situation where a traditional app falls short.

## How It Works

A single Node.js webhook server handles both voice and SMS. Vonage handles the telephony and messaging infrastructure, the server sits in the middle, and OpenClaw provides the AI.

**Voice flow:**

1. You call your Vonage number
2. Vonage picks up and greets you
3. You speak and Vonage transcribes your speech to text
4. The text goes to OpenClaw, which generates a response
5. Vonage speaks the response back to you using text-to-speech
6. Repeat until you hang up

**SMS flow:**

1. You send an SMS to your Vonage number
2. Vonage forwards it to your webhook server
3. The server sends your message to OpenClaw
4. OpenClaw generates a reply
5. The server sends the reply back as an SMS via the Vonage Messages API

Response time for both is typically 3 to 5 seconds, fast enough that it feels natural.

## What You'll Need

- An **OpenClaw** instance running on a server (see [Setting Up OpenClaw on a VPS](#setting-up-openclaw-on-a-vps) below)
- A **Vonage account** with a rented phone number (country-dependant - for UK, about €0.90/month)
- A **public IP** or domain that Vonage can reach
- About **15 minutes** to set everything up

## Setting Up OpenClaw on a VPS

Before you can use the Vonage skill, you need OpenClaw running on a server with a public IP that Vonage can reach. A VPS (Virtual Private Server) is the most common choice; providers like [Hetzner](https://www.hetzner.com/), [DigitalOcean](https://m.do.co/c/b1a117c04631), or [Oracle Cloud](https://www.oracle.com/cloud/) all work well. Oracle Cloud's Always Free tier is a solid option if you want to experiment at zero cost.

### System Requirements

- **OS:** Ubuntu 22.04 or 24.04 (recommended)
- **RAM:** 2 GB minimum, 4 GB recommended
- **Disk:** 10 GB+
- **Node.js:** Version 22 or newer

### Install OpenClaw

SSH into your server and run:

```bash
curl -fsSL https://openclaw.ai/install.sh | bash
```

Then run the onboarding wizard:

```bash
openclaw onboard --install-daemon
```

This walks you through configuring your AI provider (e.g. Anthropic, OpenAI), authentication, and gateway settings. Once complete, verify the gateway is running:

```bash
openclaw gateway status
```

### Enable the Chat Completions API

The skill communicates with OpenClaw through its chat completions HTTP endpoint. Enable it:

```bash
openclaw config set gateway.http.endpoints.chatCompletions.enabled true
```

Note the gateway URL (`http://127.0.0.1:18789` by default) and your gateway token as you'll need them when configuring the webhook server.

### Firewall Basics

Open the ports you'll need. Port 62529 is for the webhook server (And if you're wondering where that number came from? It's "oclaw" on a phone keypad):

```bash
sudo ufw allow OpenSSH
sudo ufw allow 62529/tcp
sudo ufw enable
```

Your OpenClaw instance is now ready to serve as the backend for the skill.

## Step 1: Configure Vonage

Head to the [Vonage Dashboard](https://dashboard.vonage.com):

1. **Create an application**:  enable both the **Voice** and **Messages** capabilities. You'll need to provide webhook URLs when enabling each:
   - **Voice - Answer URL:** `http://<your-server-ip>:62529/webhooks/answer` (POST)
   - **Voice - Event URL:** `http://<your-server-ip>:62529/webhooks/event` (POST)
   - **Messages - Inbound URL:** `http://<your-server-ip>:62529/webhooks/inbound`
   - **Messages - Status URL:** `http://<your-server-ip>:62529/webhooks/status`
2. **Rent a number** with voice and SMS support, and link it to the application
3. **Important:** Go to Settings and set **Default SMS Setting** to **"Messages API"** (not "SMS API")

That last step trips people up; if you skip it, inbound SMS messages won't reach your webhook.

Save the Application ID, the private key, and note your phone number since you'll need all three during setup.

## Step 2: Install the Skill

Clone the skill into your OpenClaw skills directory:

```bash
git clone https://github.com/pardel/vonage-unofficial-skill ./skills/vonage-unofficial
```

Then restart or reload the OpenClaw runtime so it picks up the new skill.

## Step 3: Scaffold the Server

The skill includes a setup script that generates a complete Node.js project. It will prompt you for your Vonage credentials and private key. The OpenClaw gateway URL and token are detected automatically, and your server's public IP is picked up too, so most prompts will already have the right defaults:

```bash
./skills/vonage-unofficial/scripts/setup.sh ~/code/vonage
```

## Step 4: Start the Server

```bash
cd ~/code/vonage && node server.js
```

Call your number. Text your number. Both should work.

## Voice: What It Feels Like

The first time you call and hear your agent respond to your voice, it clicks: this is how AI should work sometimes. Not everything needs a screen.

Some things that work well over voice:

- **Quick questions**:  "What's on my calendar today?"
- **Dictating notes**:  "Remember that I need to call the dentist"
- **Hands-free control**:  useful when you're driving, cooking, or away from a screen
- **Just chatting**:  sometimes it's nice to talk

### Tuning the Voice Experience

The server has a few knobs you can adjust in `server.js`:

- **`endOnSilence`** (default: 2s):  How long to wait after you stop speaking. Lower means faster responses but might cut you off mid-pause.
- **`startTimeout`** (default: 20s):  How long to wait for you to start speaking before giving up.
- **`maxDuration`** (default: 60s):  Maximum length of a single utterance.
- **`language`** (default: `en-GB`):  Change to match your accent for better recognition.

## SMS: Conversation Memory

The server maintains conversation history per phone number. When you text back and forth, the agent remembers the context, just like a real text conversation.

History is kept for 2 hours of inactivity, then cleared. This keeps things lightweight while allowing natural multi-turn conversations.

The system prompt instructs the agent to keep replies concise (aiming for ~160 characters per segment), because nobody wants to read an essay over SMS.

### Sending Proactive Messages

The server isn't just reactive, it can send messages too. There's a built-in `/send` endpoint:

```bash
curl -X POST http://localhost:62529/send \
  -H 'Content-Type: application/json' \
  -d '{"to": "447700900001", "text": "Hey! Just a reminder about your meeting at 3pm."}'
```

This is useful for building reminder systems, alerts, or having your agent reach out when something important happens.

## Logs

The server logs everything to stdout and `vonage.log` with clear tags, making debugging straightforward:

**Voice:**

```log
[2026-02-10T11:25:02Z] [ANSWER] from=447700900000 to=447700900001 conv=CON-abc123
[2026-02-10T11:25:08Z] [TRANSCRIPT] conv=CON-abc123 "What's the weather like today?"
[2026-02-10T11:25:11Z] [CLAW-REPLY] conv=CON-abc123 elapsed=2834ms reply="It's about 8 degrees and cloudy..."
```

**SMS:**

```log
[2026-02-10T13:55:51Z] [INBOUND] from=447700900001 text="Are you getting my texts?"
[2026-02-10T13:55:54Z] [CLAW-REPLY] from=447700900001 elapsed=2875ms reply="Yep, loud and clear"
[2026-02-10T13:55:55Z] [SMS-OK] to=447700900001 messageId=d03b41e0-...
```

## Cost

Vonage pricing varies by country, but it's affordable for personal use. In the UK, for example:

- **Number rental:** ~€1.00/month
- **Voice calls:** a few cents per minute (typically ~€0.004/minute for inbound, ~€0.023/minute for outbound to mobile, ~€0.004/minute to landline)
- **SMS (UK):** ~€0.05 to send, ~€0.006 to receive

For typical usage, a handful of calls and texts per day, you're looking at well under €5/month total.

## Ideas to Build On

- **Daily briefings**:  have your agent call or text you a morning summary
- **Caller ID recognition**:  greet different callers by name
- **Two-factor workflows**:  text "approve" to confirm an action
- **Outbound calls**:  have your agent call you with reminders
- **Keyword shortcuts**:  text "w" for weather, "c" for calendar
- **DTMF menus**:  "Press 1 for..." style options on voice
- **Call recording**:  save voice conversations for reference

The phone is the most universal computing device on the planet. Connecting your AI agent to it, by voice and text, opens up possibilities that app-based interfaces simply can't match.

---

*The vonage-unofficial skill is available on [GitHub](https://github.com/pardel/vonage-unofficial-skill). Clone it into your OpenClaw skills directory to get started.*
