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

Just deployed

/var/lib/postgresql

/app/uploads

Just deployed

/data

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
#!/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):

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


Template Content

More templates in this category

View Template
Rocky Linux
Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀

codestorm
51
View Template
Foundry Virtual Tabletop
Self-hosted virtual tabletop for role-playing games (license required)

Lucas
71
View Template
NEW
Double Commander in your browser
The Double Commander file manager in the cloud, from any device

Nermin Sabanovic
0