Deploy and Host WhatsMiau on Railway

WhatsMiau is a lightweight, self-hosted WhatsApp REST API built in Go with the Whatsmeow library — connect a personal WhatsApp account over HTTP with no Meta Business API approval. Send messages, manage groups, receive webhooks, and automate workflows through a clean REST interface. Because it uses Whatsmeow's native WebSocket protocol instead of a headless browser, it runs in a tiny footprint — no Chromium, low RAM, fast startup.

Its standout feature: WhatsMiau is route-compatible with Evolution API, so existing Evolution integrations migrate with minimal changes. Self-host on Railway for ~$5–10/month flat — no per-message fees, no per-conversation billing, and your instance data on infrastructure you own.

What This Template Deploys

Service	Purpose
WhatsMiau	The Go REST API on port `8080` — instance creation, QR connection, messaging, group management, and webhooks
PostgreSQL	Persistence for instances and message data
Redis	Session storage and caching

All services connect over Railway's private network with credentials injected automatically. A persistent volume at /app/data holds WhatsApp authentication data so instances reconnect after restarts without re-scanning the QR code.

About Hosting WhatsMiau

WhatsMiau needs three things to run in production: a PostgreSQL database for instances and data, Redis for session storage and caching, and a persistent volume for WhatsApp auth state. The API listens on port 8080 and exposes REST endpoints for creating instances, connecting via QR code, sending messages, and configuring webhooks. Wiring that by hand on a VPS means Docker Compose, a database, Redis, and volume management.

Railway provisions all of it — PostgreSQL, Redis, the app, and a persistent volume — over private networking with automatic SSL and scaling. The Whatsmeow engine keeps the whole stack light: no headless browser, so it uses a fraction of the RAM of Puppeteer-based WhatsApp APIs.

Account-safety note: WhatsMiau connects a personal WhatsApp account through an unofficial API. WhatsApp/Meta detects and bans accounts that automate messaging or send bulk/unsolicited messages, and 2026 terms restrict unofficial API use. Use a dedicated number you can afford to lose, warm it up gradually, message only opted-in contacts, and respect rate limits. For officially sanctioned high-volume sending, use the WhatsApp Business API. This risk is inherent to all unofficial WhatsApp APIs, not specific to this template.

Typical cost: ~$5–10/month on Railway's Hobby plan for the API, PostgreSQL, and Redis. WhatsMiau is open source — you pay only compute, with no per-message or per-conversation fees.

Deploy in Under 5 Minutes

Click Deploy on Railway — WhatsMiau, PostgreSQL, and Redis build automatically (~3 minutes)
DB_URL, REDIS_URL, and API_KEY are wired via Railway reference variables
Add a persistent volume mounted at /app/data for WhatsApp auth data
Create an instance via the API, then fetch the QR code and scan it with WhatsApp
Send your first message with a REST call — text, media, or group message

No SSH. No Docker Compose. No browser engine to manage.

Common Use Cases

Chatbots and conversational automation — drive a WhatsApp bot from your backend over a clean REST API without Meta Business API approval
Notifications, alerts, and broadcasts — send order updates, OTPs, and system alerts to opted-in contacts from your app via HTTP
Customer support and helpdesk integration — wire WhatsApp into your support stack with webhooks delivering inbound messages to your system
Multi-instance management for agencies — run and manage multiple WhatsApp instances from one deployment for different clients or numbers
Lightweight migration from Evolution API — WhatsMiau's Evolution-compatible routes let you move existing Evolution integrations to a smaller Go footprint with minimal code changes
n8n and workflow automation — call the REST API from n8n, Make, or any workflow tool to automate WhatsApp sends and reactions

Configuration

Variable	Required	Description
`DIALECT_DB`	✅ Pre-set	`postgres` — the database dialect
`DB_URL`	✅ Auto-injected	PostgreSQL connection string — `${{Postgres.DATABASE_URL}}`
`REDIS_URL`	✅ Auto-injected	Redis connection string — `${{Redis.REDIS_URL}}`
`API_KEY`	✅ Auto-generated	Auth key for API requests — `${{secret(64)}}`; required on every call
`PORT`	✅ Pre-set	`8080` — the API port

Mount a persistent volume at /app/data for WhatsApp auth data, or instances re-scan the QR code on every redeploy. Keep API_KEY secret — it authenticates all API requests. Run a single instance per WhatsApp number to avoid session conflicts.

WhatsMiau vs. Alternatives

	WhatsMiau (Railway)	Evolution API	WAHA	Official Business API
Engine	✅ Go / Whatsmeow (light)	Node / Baileys	Multi-engine	Meta cloud
RAM footprint	✅ Very low (no browser)	Low–medium	Varies	N/A
Meta approval needed	✅ No	✅ No	✅ No	❌ Required
Per-message fees	✅ None	✅ None	✅ None	❌ Per conversation
Evolution-compatible routes	✅ Yes	✅ Native	❌ No	❌ No
Webhooks	✅ Yes	✅ Yes	✅ Yes	✅ Yes
Multi-instance	✅ Yes	✅ Yes	✅ Yes	✅ Yes
Self-hostable	✅ Yes	✅ Yes	✅ Yes	❌ No
Ban-risk (unofficial)	⚠️ Real — see note	⚠️ Real	⚠️ Real	✅ Sanctioned

Dependencies for WhatsMiau Hosting

Railway account — Hobby plan (~$5–10/month) covers the API, PostgreSQL, and Redis
A persistent volume mounted at /app/data for WhatsApp instance auth data
A dedicated WhatsApp number for automation (not your primary personal number)

Deployment Dependencies

WhatsMiau on Docker Hub — the image this template deploys
Whatsmeow Library — the Go WhatsApp library WhatsMiau is built on
Evolution API Documentation — compatible route reference
Railway Documentation — deployment and variables

Implementation Details

This template deploys impedr029/whatsmiau (Go + Whatsmeow) alongside PostgreSQL and Redis over Railway's private network, with a persistent volume at /app/data for WhatsApp auth state. DB_URL, REDIS_URL, and API_KEY are wired via Railway reference variables; the API listens on port 8080. Because WhatsMiau uses Whatsmeow's native WebSocket protocol rather than a headless browser, its memory footprint is a fraction of Puppeteer-based WhatsApp APIs.

WhatsMiau's routes are compatible with Evolution API, so integrations built against Evolution can often point at a WhatsMiau instance with minimal changes — useful for moving to a lighter Go stack. Run one instance per WhatsApp number, since WhatsApp permits a single active session per login.

Frequently Asked Questions

How is WhatsMiau different from Evolution API or WAHA? WhatsMiau is built in Go with the Whatsmeow library, giving it a very low memory footprint (no headless browser). It's route-compatible with Evolution API, so existing Evolution integrations migrate with minimal changes — the main draw is a lighter, faster stack for the same REST workflows. Evolution and WAHA have larger ecosystems and more engines; WhatsMiau trades breadth for a lean Go runtime.

Do I need Meta's WhatsApp Business API approval? No. WhatsMiau connects a personal WhatsApp account over an unofficial API, so there's no Meta approval step. The trade-off is that unofficial APIs carry ban risk and can't send pre-approved template messages — for sanctioned high-volume outbound, use the official Business API.

Is it safe for my WhatsApp account? There's real risk. WhatsApp bans accounts that automate messaging or send bulk/unsolicited messages. Use a dedicated number, warm it up gradually, message only opted-in contacts, and respect rate limits. Never use your primary personal number.

Do I lose my WhatsApp session if Railway redeploys? Not if you mount the persistent volume at /app/data — auth data lives there and instances reconnect without re-scanning the QR code. Instance and message data persist in PostgreSQL. Without the volume, you re-scan on each redeploy.

Can I migrate my Evolution API integration to WhatsMiau? Yes — that's a core design goal. WhatsMiau implements Evolution-compatible routes, so most integrations can point at a WhatsMiau instance with minimal changes. Test your specific endpoints, since compatibility covers common routes rather than every Evolution feature.

Can I run multiple WhatsApp numbers? Yes. WhatsMiau supports multiple instances, so agencies can manage several numbers from one deployment. Run one active session per number to avoid conflicts, and size your Railway resources to the number of concurrent instances.

Why Deploy and Host WhatsMiau 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 WhatsMiau on Railway, you get a lightweight Go-based WhatsApp REST API — Evolution- compatible routes, webhooks, and multi-instance support — with PostgreSQL, Redis, and persistent auth storage wired automatically, at ~$5–10/month flat with no per-message fees.