---
title: "Deploy Whatomate | (Just Updated) WhatsApp Business Platform, Shared Inbox, Chatbot and Campaigns, Admin Login Pre-Created"
description: "Whatomate WhatsApp Business platform, shared inbox, chatbot and campaigns"
category: "Other"
url: https://railway.com/deploy/whatomate-or-just-updated-whatsapp-busin
---

# Deploy Whatomate | (Just Updated) WhatsApp Business Platform, Shared Inbox, Chatbot and Campaigns, Admin Login Pre-Created

Whatomate WhatsApp Business platform, shared inbox, chatbot and campaigns

**[Deploy Whatomate | (Just Updated) WhatsApp Business Platform, Shared Inbox, Chatbot and Campaigns, Admin Login Pre-Created on Railway](https://railway.com/template/whatomate-or-just-updated-whatsapp-busin)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/whatomate-or-just-updated-whatsapp-busin/manifest.json

- **Creator:** SuperSlowSloth
- **Category:** Other

## Template content

### database

- **Image:** postgres:17-alpine@sha256:526f86d93c6ea08fd3f1fe5605650cacc781b2c6013169a0ad8f42c7d3d84f32

### whatomate

- **Image:** ghcr.io/bon5co/whatomate-railway:0.1.1-beta-0.17@sha256:c64cdaa9f5e4947acb3acbbde35dabfb3bd936dc5169eec122d469c4fb93261a
- **Health check:** /health
- **Public domain:** Yes

### cache

- **Image:** redis:8.2.1-alpine@sha256:987c376c727652f99625c7d205a1cba3cb2c53b92b0b62aade2bd48ee1593232
- **Start command:** `/bin/sh -c 'chown -R redis:redis /data && exec docker-entrypoint.sh redis-server --requirepass "$REDIS_PASSWORD" --appendonly yes --dir /data'`

## Documentation

# Deploy and Host Whatomate on Railway

**Built for an LLM agent to deploy and use.** The deploy form has no fields to fill: the administrator login, the JWT secret, the encryption key and the database and Redis credentials are generated, and the administrator is created at boot, so the stock `admin@admin.com` / `admin` login of the upstream image does not exist. Whatomate is an open-source WhatsApp Business platform: a shared team inbox, chatbot flows, bulk campaigns, message templates, contact management and a REST API on top of the WhatsApp Cloud API.

## About Hosting Whatomate

This template runs three services: **whatomate**, the official `shridh0r/whatomate` image (0.1.1-beta-0.17) pinned by digest through a thin wrapper, with a volume at `/app/uploads` for media; **database**, a PostgreSQL 17 instance with a volume at `/var/lib/postgresql` that holds contacts, chats, flows and settings; and **cache**, a Redis 8 instance with a volume at `/data`. One public domain serves the dashboard, the API and the WhatsApp webhook (`/api/webhook`). The healthcheck is `GET /health`.

**What the wrapper fixes.** The upstream image ships no configuration file, refuses to start in production without a 32-character JWT secret and an allowed-origins list, and creates a default administrator of `admin@admin.com` with the password `admin`, which anyone on a public domain can sign in with. The wrapper builds every `WHATOMATE_SECTION__KEY` style setting from plain Railway variables, binds the server to Railway's injected `PORT`, allows the Railway domain as the origin, and creates the administrator from `WHATOMATE_ADMIN_EMAIL` and `WHATOMATE_ADMIN_PASSWORD`. The default administrator is created only while no user exists, so a redeploy never touches existing data. Registration needs the UUID of an organization, which only an invitation link carries, so a stranger cannot create an account. Measured on a Railway control deploy: the stock login is refused and the generated login works.

**Using it.** Open the domain and sign in with `WHATOMATE_ADMIN_EMAIL` and `WHATOMATE_ADMIN_PASSWORD`. To send and receive messages, add a WhatsApp Business account under Settings: Meta gives you an access token and a phone number ID, and you point Meta's webhook at `https://YOUR_DOMAIN/api/webhook`. Whatomate is released under AGPL-3.0.

### Agent contract

- Public URL: `https://RAILWAY_PUBLIC_DOMAIN` (the generated domain of the `whatomate` service)
- Private URL: `http://whatomate.railway.internal:8080`
- Credentials: the variables `WHATOMATE_ADMIN_EMAIL` and `WHATOMATE_ADMIN_PASSWORD` on the `whatomate` service (plain text)
- Auth: `POST /api/auth/login` with JSON `{"email","password"}` sets auth cookies; send the cookie jar on every call under `/api/`, and on writes echo the `whm_csrf` cookie value in an `X-CSRF-Token` header. Whatomate also issues per-user API keys for programmatic access
- Health: `GET /health` returns 200 without credentials

```bash
#!/bin/sh
# needs: RAILWAY_PUBLIC_DOMAIN, WHATOMATE_ADMIN_EMAIL, WHATOMATE_ADMIN_PASSWORD (variables of the whatomate service); also curl, jq.
R="https://$RAILWAY_PUBLIC_DOMAIN"; J="content-type: application/json"; JAR=$(mktemp)
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/health")" = 200 ]; do n=$((n+1)); [ "$n" -le 90 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/health"
# registration needs the UUID of an organization (only invitation links carry it), so a stranger cannot create an account
curl -s -o /dev/null -w "public signup: %{http_code}\n" -H "$J" -d '{"email":"x@example.com","password":"stranger-twelve-chars","full_name":"x","organization_id":"00000000-0000-4000-8000-000000000000"}' "$R/api/auth/register"
# the stock login of the upstream image (admin@admin.com) does not exist on this deploy
curl -s -o /dev/null -w "stock login: %{http_code}\n" -H "$J" -d '{"email":"admin@admin.com","password":"admin-admin-admin"}' "$R/api/auth/login"
# sign in: the cookies set here authenticate every call after this
curl -s -o /dev/null -w "login: %{http_code}\n" -c "$JAR" -H "$J" -d "$(jq -nc --arg e "$WHATOMATE_ADMIN_EMAIL" --arg p "$WHATOMATE_ADMIN_PASSWORD" '{email:$e,password:$p}')" "$R/api/auth/login"
# a read with the session succeeds, the same read without it is refused
curl -s -o /dev/null -w "read with session: %{http_code}\n" -b "$JAR" "$R/api/tags"
curl -s -o /dev/null -w "read without session: %{http_code}\n" "$R/api/tags"
# write-auth: a write needs the session cookie plus its CSRF token echoed in a header; without the session it is refused
CSRF=$(awk '$6=="whm_csrf"{print $7}' "$JAR")
curl -s -o /dev/null -w "write with session: %{http_code}\n" -b "$JAR" -H "$J" -H "X-CSRF-Token: $CSRF" -d '{"name":"agent-check","color":"blue"}' "$R/api/tags"
curl -s -o /dev/null -w "write without key: %{http_code}\n" -H "$J" -d '{"name":"agent-check","color":"blue"}' "$R/api/tags"
```

Expected output against a fresh deploy (measured on a Railway control deploy of the published template; the output is recorded in `template.md`):

```text
health: 200
public signup: 404
stock login: 401
login: 200
read with session: 200
read without session: 401
write with session: 200
write without key: 401
```

The refusals are the contract: a read or write without a session answers 401 (`write without key: 401`), and a registration from a stranger is refused (`public signup: 404`).

## Why Deploy Whatomate on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Whatomate on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.

- **Agent-ready** - no deployer fields, a contract block, and one script that proves the server is healthy, a stranger cannot register, the stock login is gone, and the generated login can read and write.
- **No default password** - the administrator is created from a generated password, not `admin`.
- **Data survives redeploys** - contacts and chats in PostgreSQL on a volume, media on a volume, rate-limit state in Redis on a volume.
- **Pinned** - the upstream image is pinned by digest and the wrapper by tag and digest.

## Common Use Cases

- **Shared WhatsApp inbox** - several agents answer customers from one WhatsApp Business number.
- **Chatbots and campaigns** - build keyword and flow-based bots and send template campaigns to contact lists.
- **WhatsApp automation with AI agents** - create contacts, tags and messages and read conversations through the API.

## Dependencies for Whatomate Hosting

- The whatomate service, a PostgreSQL service and a Redis service, each with its volume, created by the template.

### Deployment Dependencies

- [Whatomate repository](https://github.com/shridarpatil/whatomate)
- [Wrapper image source](https://github.com/bon5co/whatomate-railway)


## Similar templates

- [Rocky Linux](https://railway.com/deploy/rocky-linux) — Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀
- [Foundry Virtual Tabletop](https://railway.com/deploy/X5tR6G) — Self-hosted virtual tabletop for role-playing games (license required)
- [Double Commander in your browser](https://railway.com/deploy/double-commander-in-your-browser) — The Double Commander file manager in the cloud, from any device

Open this page in a browser: https://railway.com/deploy/whatomate-or-just-updated-whatsapp-busin
