Deploy and Host Evolution Go on Railway

Evolution Go is a high-performance WhatsApp API built in Go — part of the Evolution ecosystem, rewritten for speed and a tiny footprint. Built on the whatsmeow library (native WhatsApp protocol, no headless browser), it sends and receives messages, manages groups, handles media, and streams events over webhooks, WebSocket, RabbitMQ, or NATS, all through a clean REST API with Swagger docs. This template deploys Evolution Go with a persistent volume and API-key authentication — a fast, resource-efficient WhatsApp REST backend, ideal when you want minimal RAM and cost over the full-featured Node stack.

What This Template Deploys

Service	Purpose
Evolution Go	The WhatsApp REST API, event engine, and Swagger docs (Go + whatsmeow)
PostgreSQL	Optional persistence for messages and instance data

Both connect over Railway's private network. Evolution Go runs as a lightweight Go binary with a persistent volume for WhatsApp session data, and optional PostgreSQL for message and instance persistence — a fast, low-resource WhatsApp backend secured by an API key.

About Hosting

Evolution Go trades the full Node feature set for speed and efficiency, and knowing what that means is the key — this template sets it up correctly.

Go and whatsmeow — the performance story. Where the original Evolution API is a Node/Baileys stack, Evolution Go is a compiled Go binary on the whatsmeow library, which speaks WhatsApp's native WebSocket protocol directly — no headless Chromium. The result is a tiny memory footprint, fast startup, and efficient concurrency, so it runs cheaply and scales well. The reason to choose Evolution Go: the same ecosystem, far lighter.

Set the API key — the endpoints control WhatsApp. Evolution Go's REST endpoints can read and send messages on connected accounts, so a public deployment must be authenticated. This template sets an AUTHENTICATION_API_KEY that every request presents, so only your applications can create instances and send messages. Keep it secret and rotate it if exposed.

Persistence is optional — go even lighter, or add Postgres. Evolution Go can run without a database for the leanest setup, or with PostgreSQL for durable message and instance storage. This template includes Postgres, and a volume holds WhatsApp session data so accounts stay linked across redeploys. For media, it supports MinIO or S3-compatible storage.

Events your way — webhooks, WebSocket, and queues. Beyond webhooks, Evolution Go delivers real-time message and status events over WebSocket, RabbitMQ/AMQP, or NATS, so it slots into event-driven and microservice architectures directly, not just simple webhook flows.

Pair a device with a QR code, and pin the version. Create an instance and Evolution Go generates a QR code to link a WhatsApp account. Use a dedicated number, warm it up, and keep outbound volume measured to protect the account, and explore every endpoint through the built-in Swagger UI. Evolution Go is the newer, Go-based ecosystem member and is actively developed, so pin the image version and check the repository for current environment variables before deploying and upgrading.

Typical cost: ~$5–10/month on Railway — Evolution Go's Go footprint is genuinely light, often less than the Node stack for the same workload. It's open source and free.

How It Compares

	Evolution Go	Evolution API (Node)	Twilio WhatsApp	Cloud API direct
Language / base	Go + whatsmeow	Node + Baileys	Managed	Managed
Footprint	Very light	Moderate	N/A	N/A
Integrations	REST, WS, AMQP, NATS	Chatwoot, Typebot, more	APIs	APIs
Meta approval	Not needed	Not needed	Needed	Needed
Cost model	Flat infra	Flat infra	Per message	Per conversation
Self-hostable	Yes	Yes	No	No

The Node Evolution API is more feature-rich, with built-in Chatwoot, Typebot, and OpenAI integrations — the better pick if you want those out of the box. Twilio and the Cloud API are reliable but require Meta approval and bill per message. Evolution Go's edge is raw efficiency: a compiled Go binary with a tiny footprint and native protocol handling, ideal for high-throughput or cost-sensitive WhatsApp workloads where you don't need the Node stack's bundled integrations — self-hosted, with your data on infrastructure you own.

Deploy in Under 5 Minutes

Click Deploy on Railway — Evolution Go and PostgreSQL build and wire together (~3 minutes)
Confirm AUTHENTICATION_API_KEY is set and the volume is mounted for session data
Open the Swagger UI at your Railway URL to explore the REST endpoints
Create an instance and scan the QR code with a dedicated WhatsApp number
Send a message via the API, and point a webhook (or WebSocket/NATS) at your app

Use a dedicated number and pace outbound messages to keep the account healthy.

Common Use Cases

High-throughput messaging — a fast, low-resource WhatsApp backend for heavy volume
Notifications and alerts — send order updates, alerts, and reminders programmatically
Microservice WhatsApp API — a lean REST service that drops into a larger architecture
Cost-sensitive self-hosting — the Evolution ecosystem at a minimal resource footprint

Configuration

Variable	Required	Description
`AUTHENTICATION_API_KEY`	Required	Secures every request — set a strong value
`DATABASE_URL`	Optional	PostgreSQL connection for message and instance persistence
`SERVER_URL`	Recommended	Your Railway domain, for correct webhook and media URLs
Storage volume	Pre-set	Persistent volume for WhatsApp session/authentication data
S3 / MinIO	Optional	Object storage for media

Set the API key and persist sessions. AUTHENTICATION_API_KEY secures the endpoints, which can send WhatsApp messages — keep it secret. A volume stores session data so accounts stay linked across redeploys. Postgres is optional for durable message storage.

Go footprint, evolving project. Evolution Go's compiled Go binary is very light on RAM. It's the newer ecosystem member, so pin the image version and check the repo for current variables before deploying.

Dependencies for Evolution Go Hosting

Railway account — ~$5–10/month for the lightweight Go service (and optional Postgres)
A dedicated WhatsApp number (not personal) to link via QR
Optional: PostgreSQL for message and instance persistence (included)
Optional: MinIO or S3-compatible storage for media

Deployment Dependencies

Implementation Details

The template runs the official Evolution Go Docker image, a compiled Go service built on the whatsmeow library, which connects to WhatsApp over the native WebSocket protocol rather than a headless browser — a small memory footprint, fast startup, and efficient concurrency compared with the Node/Baileys Evolution API. A persistent volume stores WhatsApp session and authentication data so accounts stay linked across redeploys, and PostgreSQL is included (optionally) for durable message and instance persistence; Evolution Go can also run without a database for the leanest setup.

Every request must present AUTHENTICATION_API_KEY, since the REST endpoints can read and send messages on connected accounts. SERVER_URL should be the Railway domain so webhook and media URLs resolve. Real-time events are delivered over webhooks, WebSocket, RabbitMQ/AMQP, or NATS, and media can be stored in MinIO or S3-compatible storage. Instances are linked by QR-code pairing, and every endpoint is documented in the built-in Swagger UI. Evolution Go is the newer, Go-based ecosystem member under active development, including built-in license management (registration, activation, heartbeat); pin the image version and check the repository for current variables before deploying. As with any WhatsApp Web-based tool, account-safety practices apply: a dedicated number, gradual warm-up, and measured volume.

Frequently Asked Questions

How is Evolution Go different from the Node Evolution API? Evolution Go is a Go rewrite on the whatsmeow library — much lighter on resources with a tiny footprint and fast startup, but without the Node stack's bundled Chatwoot/Typebot/OpenAI integrations. Choose Go for efficiency and throughput, Node for those built-in integrations.

Is my instance secured? Yes — this template sets AUTHENTICATION_API_KEY, and every request must include it. Since the endpoints can send WhatsApp messages, keep the key secret and rotate it if exposed.

Does it need Meta approval? No — like the rest of the Evolution ecosystem, it connects a WhatsApp account directly via QR pairing, with no Meta Business API approval. Use a dedicated number and measured volume to keep the account healthy.

Why Deploy Evolution Go 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 Evolution Go on Railway you get a fast, lightweight WhatsApp API with the essentials handled — a persistent volume for sessions, API-key authentication, optional Postgres, and automatic HTTPS. The Evolution ecosystem in an efficient Go footprint, self-hosted on infrastructure you own.