How to Send WhatsApp Messages with an Unofficial API and n8n: The Complete Guide

If you want to send and receive WhatsApp messages from an automation like n8n but you cannot (or do not want to) use the official WhatsApp Business API, you will quickly run into “unofficial” WhatsApp APIs. These are gateways that connect to WhatsApp the same way WhatsApp Web does and expose a simple HTTP API you can call from n8n. This guide covers the eight most popular options end to end: what each one is, how to set it up, the exact endpoint and payload to send a message, a side-by-side comparison, and, crucially, the trade-offs you should understand before you build anything.

What “unofficial” actually means

Official access to WhatsApp for businesses goes through Meta’s WhatsApp Business API (the Cloud API), which requires business verification, uses pre-approved message templates and charges per conversation. Unofficial APIs skip all of that: they run a WhatsApp Web session for a normal phone number (many are built on the open-source Baileys library or a headless browser) and wrap it in a REST API.

That convenience comes with a real caveat. Automating a personal number this way is not sanctioned by Meta and can violate WhatsApp’s Terms of Service. Numbers can be rate-limited or banned, most often when they are used to send unsolicited bulk messages to people who never opted in. Treat unofficial APIs as best for personal projects, internal tools, notifications and two-way chat with people who expect to hear from you. For compliant, large-scale outreach, the official API via a provider like Wati is the right route. And if you qualify for the official API but would rather not self-host anything, fully hosted automation tools like Zapier or Make connect WhatsApp through the official Cloud API with no server to run. See our automation guide for the fuller picture.

The recipe every gateway follows

Once you have seen one of these APIs, you have essentially seen them all. The differences are in hosting, pricing and payload details, the workflow is identical:

1. Link a number. You create an “instance”, “session” or “channel” for a dedicated WhatsApp number and scan a QR code from WhatsApp → Linked devices, exactly as if you were signing into WhatsApp Web.
2. Get a credential. The provider gives you an API key or token that authenticates every request.
3. Send via HTTP. In n8n, an HTTP Request node POSTs to the provider’s send endpoint with the recipient and text. (Evolution API and Wassenger also offer dedicated n8n nodes if you prefer not to build requests by hand.)
4. Receive via webhook. You point the provider’s webhook at an n8n Webhook node, so every incoming message triggers a workflow, the basis for autoresponders and chatbots.

Recipient numbers are always in full international format, digits only, the same format used by a click-to-chat link. Some providers wrap the number in a chat ID such as 15551234567@c.us (individual) or @g.us (group); the per-provider sections below note which.

Self-hosted gateways: Evolution API, WAHA, WPPConnect

Self-hosted gateways run on your own server (Docker makes this a one-command affair on any cheap VPS). You pay nothing per message and no subscription (just your server) and your message data never passes through a third party, which matters if you handle sensitive contact lists. The price is that you operate them yourself: updates, backups, and the occasional re-scan when a session drops.

Evolution API, the biggest n8n ecosystem

Evolution API is a free, open-source gateway and the most popular pick among technical teams. It wraps Baileys for the WhatsApp Web protocol (and can also front the official Cloud API), supports multiple instances (each tied to one number) and has both a dedicated community node (n8n-nodes-evolution-api) and a large ecosystem of ready-made n8n templates.

Setup: start the Docker container with a global API key (for example the AUTHENTICATION_API_KEY environment variable, the project’s docker-compose file shows the current names), create an instance via the API or manager UI, then request the instance’s QR code and scan it. Swagger docs are served from the same port for exploring endpoints.

• Send endpoint: POST https://your-server/message/sendText/your-instance
• Auth: apikey: your-api-key (header)
• Body (JSON): { "number": "15551234567", "text": "Hello from n8n + Evolution API" }

WAHA, one container, multiple engines, strong media

WAHA (WhatsApp HTTP API) runs as a single Docker image and organises connections as sessions (the default one is literally called “default”). Its distinctive feature is a choice of engines, a browser-based WEBJS engine and lighter websocket-based NOWEB/GOWS engines, so you can trade resource use against features. The core is free to self-host; a paid WAHA Plus unlocks advanced capabilities. It is particularly solid with media (images, files, voice notes), which suits richer chatbots.

Setup: run the image (API on port 3000 by default, with interactive Swagger docs), start a session, fetch its QR code and scan it. When the session status is “working”, you can send. If you protect the instance with an API key, pass it in the header WAHA expects (for example X-Api-Key).

• Send endpoint: POST http://your-waha-host:3000/api/sendText
• Body (JSON): { "session": "default", "chatId": "[email protected]", "text": "Hello from n8n + WAHA" }
• Note: the chatId suffix is @c.us for individuals, @g.us for groups.

WPPConnect, open-source with token-per-session auth

WPPConnect Server is the community sibling of the other two: free, open-source and self-hosted, commonly on port 21465 with Swagger docs. Its auth model is slightly different: you set a SECRET_KEY on the server, call the generate-token endpoint to mint a Bearer token for a named session, start the session and scan its QR. It exposes endpoints for media, files, buttons and groups as well as plain text.

• Send endpoint: POST http://your-server:21465/api/your-session/send-message
• Auth: Authorization: Bearer your-session-token
• Body (JSON): { "phone": "14155550100", "message": "Hello from n8n + WPPConnect" }

Cloud gateways: Green API, UltraMsg, Wassenger, Whapi.cloud, Maytapi

Cloud gateways host everything for you: you sign up, link a number by QR and start calling an API, often inside ten minutes, with nothing to maintain. In exchange you pay a subscription and your traffic routes through the provider’s servers. All five below follow the same pattern and differ mainly in pricing, polish and one or two stand-out features.

Green API, quickest start, free developer tier

Green API gives each instance two values (an idInstance and an apiTokenInstance) which are embedded directly in the request URL, so there are no headers to configure at all. It has a free developer tier for testing, clear documentation, and allows very long text messages. Incoming messages arrive either by webhook or by polling its notification queue with ReceiveNotification; webhooks are the cleaner choice with n8n.

• Send endpoint: POST https://api.green-api.com/waInstance{idInstance}/sendMessage/{apiTokenInstance}
• Body (JSON): { "chatId": "[email protected]", "message": "Hello from n8n + Green API" }

UltraMsg, the simplest, low-cost option

UltraMsg is the minimalist of the group: you get an instance ID (like instance12345) and a token, and you send messages with a single form-encoded request, no JSON, no special node. A successful response looks like { "sent": "true", "message": "ok", "id": 497 }. It is a pragmatic pick for simple notifications and small chatbots where cost and setup time matter most.

• Send endpoint: POST https://api.ultramsg.com/instance12345/messages/chat
• Body (Form-Urlencoded): token = your-token, to = 15551234567, body = Hello from n8n + UltraMsg

Wassenger, business features and a native n8n node

Wassenger is aimed at business users: it adds a shared team inbox on top of the API and, notably, ships a native n8n integration, so you can drop in a Wassenger node instead of configuring HTTP requests. You connect a device by QR, create an API key, and pass it in a Token header. Beyond text it can send media, documents, locations, polls and buttons, and message groups.

• Send endpoint: POST https://api.wassenger.com/v1/messages
• Auth: Token: your-api-key (header)
• Body (JSON): { "phone": "+14155550100", "message": "Hello from n8n + Wassenger" }

Whapi.cloud, clean REST with per-channel tokens

Whapi.cloud treats each connected number as a “channel” with its own Bearer token, a tidy model if you run several numbers for different purposes. The REST endpoints are clean and well documented, there is a free tier for prototyping, and the to field accepts group and channel IDs as well as individual numbers (digits only, no plus sign).

• Send endpoint: POST https://gate.whapi.cloud/messages/text
• Auth: Authorization: Bearer your-channel-token
• Body (JSON): { "to": "14155550100", "body": "Hello from n8n + Whapi.cloud" }

Maytapi, built for managing several numbers

Maytapi’s stand-out feature is multi-phone support: one account (a “product”) can hold several phone instances, each addressed by its own phone ID in the URL. You authenticate with a token in an x-maytapi-key header, and the same endpoint sends media, locations and contacts by changing the type field. Webhooks are configured once per product.

• Send endpoint: POST https://api.maytapi.com/api/your-product-id/your-phone-id/sendMessage
• Auth: x-maytapi-key: your-token (header)
• Body (JSON): { "to_number": "14155550100", "type": "text", "message": "Hello from n8n + Maytapi" }

Comparison table

All eight side by side. “Self-hosted” means you run it (typically with Docker) and pay only for your server; “cloud” means the provider hosts it and you pay them. None quote fixed prices here, always check the provider’s current pricing.

Endpoint cheat-sheet

For quick reference when you are wiring up the n8n HTTP Request node, the send-a-text call for each provider, condensed:

Which should you choose?

• Want full control and no per-message cost, and can run a server? Self-host Evolution API, WAHA or WPPConnect.
• Want zero infrastructure and the quickest start? Use a cloud gateway, Green API, UltraMsg, Whapi.cloud, Wassenger or Maytapi.
• Want a first-class n8n node rather than raw HTTP? Evolution API (community node) or Wassenger (native integration).
• Need to manage several WhatsApp numbers? Maytapi is built for that.
• Need the biggest n8n template/community ecosystem? Evolution API.
• Need compliant, opted-in messaging at real scale? Step up to the official API with Wati instead of an unofficial gateway.

Receiving messages and building a chatbot

Sending is only half the story. Every provider above can deliver incoming messages to a URL you choose, point that webhook at an n8n Webhook node and each inbound WhatsApp message becomes a workflow trigger. The classic two-way pattern is: inbound message → look up the sender in your data (a sheet, a CRM, a database) → optionally run an AI step to draft a reply → send the response back through the same send endpoint. That is a complete autoresponder or chatbot, built entirely from n8n nodes. Common builds: an FAQ answerer that hands off to a human when unsure, order or appointment notifications triggered from a spreadsheet, and AI assistants that can even transcribe incoming voice notes (WAHA’s media handling is particularly good for that).

Staying safe whichever you pick

• Use a dedicated number you are willing to lose, not your main personal line.
• Warm it up, start slow, and only message people who expect you.
• Never cold-blast unsolicited bulk messages; that is the fastest way to a ban.
• Respect opt-outs, keep volumes reasonable and add human-like delays between messages.

Frequently asked questions

Are unofficial WhatsApp APIs legal?

They are widely used, but automating a personal WhatsApp number this way can breach WhatsApp’s Terms of Service, and Meta may ban numbers, especially for unsolicited bulk messaging. Use them for personal projects and opted-in, two-way chat, and use the official API for large-scale marketing.

Do I need to write code to use them with n8n?

Not really. In n8n you can call any of these with the HTTP Request node, and Evolution API and Wassenger even have dedicated nodes. You configure the endpoint and token, no traditional programming required.

Which is best for beginners?

If you don’t want to run a server, a cloud option like Green API or UltraMsg is quickest. If you are comfortable with Docker and want no per-message fees, Evolution API or WAHA give you more control.

What is the @c.us chat ID format some providers use?

It is the recipient’s number in full international format (digits only) followed by @c.us for an individual chat, e.g. [email protected], or @g.us for a group. WAHA and Green API use it; the others take a bare number field.

Are the self-hosted options really free?

Yes, Evolution API and WPPConnect are open-source and free to self-host, and WAHA has a free core (plus a paid Plus tier). Your only costs are the server they run on and, if you use one, an n8n plan. There are no per-message fees because they use a WhatsApp Web session rather than the paid official API.

Can these get my number banned?

Any of them can, if you send unsolicited bulk messages, the gateway doesn’t matter, the behaviour does. Use a dedicated number, message only people who expect you, keep volumes modest, and consider the official API for large campaigns.