Parte 1: Se você não tem tempo para ler
- Responder a um comando desconhecido, isso pode ser uma instrução ou sua mensagem de boas-vindas;
- Enviar mensagem regular;
- Enviar imagem;
- Enviar arquivo;
- Enviar vídeo;
- Enviar contato (vCard);
- Enviar produto;
- Criar novo grupo, enviar convite e enviar mensagem para o grupo;
- Receber e ler mensagens recebidas;
E se precisar de ajuda, é só escrever para nós no chat de suporte em qualquer página do site.
Parte 2: Introdução
O que é um bot de WhatsApp e por que você precisa de um?
Por que Node.js?
- Programação Assíncrona. Node.js é não bloqueante, o que significa que pode lidar com várias conexões simultaneamente, perfeito para um chatbot que precisa gerenciar múltiplas interações de uma só vez.
- Amplo Suporte da Comunidade. Com um ecossistema vibrante e um grande número de módulos gratuitamente disponíveis no registro npm, você nunca está realmente sozinho quando está programando em Node.js.
- Facilidade de Aprendizado. Se você já está familiarizado com JavaScript, aprender Node.js será muito fácil. Mesmo que você não esteja, JavaScript é uma das linguagens de programação mais fáceis de aprender.
- Nosso Suporte. Estamos felizes em ajudar os desenvolvedores nesta linguagem de programação. Se você nos enviar um fragmento do seu código onde algo não está funcionando, será mais fácil para nós ajudá-lo, dar uma dica ou melhorar seu trabalho.
Configurando o Ambiente de Desenvolvimento
- Node.js e npm. Se você não tem Node.js e npm (Node Package Manager) instalados em seu computador, precisará instalá-los. Você pode baixar a última versão no site oficial do Node.js.
- Editor de Texto. Qualquer editor de texto servirá, mas IDEs como o Visual Studio Code ou o WebStorm oferecem recursos adicionais como depuração e auto-completar que podem facilitar sua vida.
- Terminal ou Prompt de Comando. É aqui que você executará todos os seus scripts Node.js.
Passos para a Instalação
- Passo 1: Instale Node.js e npm. Visite o site oficial do Node.js e baixe o instalador para o seu sistema operacional. Execute o instalador e siga as instruções na tela. Isso instalará tanto o Node.js quanto o npm.
- Passo 2: Configure a pasta do seu projeto. Crie uma nova pasta onde você armazenará todos os arquivos relacionados ao seu bot do WhatsApp. Navegue até a pasta usando o terminal. Inicialize um novo projeto Node.js. Isso criará um arquivo package.json que conterá todos os metadados e dependências do seu projeto.
- Passo 3: Instale os pacotes necessários. Como estaremos trabalhando com a API do WhatsApp, precisaremos instalar alguns pacotes para nos ajudar na tarefa.
Conectando o provedor de API do WhatsApp
Como conectar ao Whapi.Cloud




Estabelecendo a base do bot de WhatsApp
Inicializando o servidor com Express
npm install express --save
const express = require('express');
const app = express();
const port = 3000;
app.listen(port, () => {
console.log(`Server running on http://localhost:${port}/`);
});
Noções básicas de programação assíncrona em Node.js
async function fetchData() {
const data = await getData();
console.log(data);
}
Gerenciando Mensagens Recebidas
Exploramos todos os detalhes do trabalho com webhooks em mais detalhes na nossa base de conhecimento: Ver artigo sobre webhooks


Roteamento e Manipulação de Requisições
const express = require('express');
const app = express();
app.use(express.json());
app.post('/webhook', (req, res) => {
// Handle incoming messages
});
app.listen(3000, () => {
console.log('Server started');
});
app.post('/webhook', async (req, res) => {
const message = req.body.message.text;
if (message === 'hello') {
await sendMessage('Hi there!');
} else if (message === 'help') {
await sendMessage('How can I assist you today?');
}
res.sendStatus(200);
});
Enviar mensagem do WhatsApp usando Node JS
Enviando mensagens de texto
const request = require('request');
const options = {
method: 'POST',
url: 'https://gate.whapi.cloud/messages/text?token=YOUR_API_TOKEN',
headers: {accept: 'application/json', 'content-type': 'application/json'},
body: {typing_time: 10, to: '1234567891@s.whatsapp.net', body: 'Hello, world!'},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});
Enviando multimídia, documentos
const request = require('request');
const options = {
method: 'POST',
url: 'https://gate.whapi.cloud/messages/document?token=YOUR_API_TOKEN',
headers: {accept: 'application/json', 'content-type': 'application/json'},
body: {
to: '1234567891@s.whatsapp.net',
media: 'data:application/octet-stream;name=site.webmanifest;base64,ewogICAgIm5hbWUiOiAiIiwKICAgICJzaG9ydF9uYW1lIjogIiIsCiAgICAiaWNvbnMiOiBbCiAgICAgICAgewogICAgICAgICAgICAic3JjIjogIi9hbmRyb2lkLWNocm9tZS0xOTJ4MTkyLnBuZyIsCiAgICAgICAgICAgICJzaXplcyI6ICIxOTJ4MTkyIiwKICAgICAgICAgICAgInR5cGUiOiAiaW1hZ2UvcG5nIgogICAgICAgIH0KICAgIF0sCiAgICAidGhlbWVfY29sb3IiOiAiI2ZmZmZmZiIsCiAgICAiYmFja2dyb3VuZF9jb2xvciI6ICIjZmZmZmZmIiwKICAgICJkaXNwbGF5IjogInN0YW5kYWxvbmUiCn0K'
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});


Trabalhando com grupos de WhatsApp usando Node.JS
Obtendo a lista de grupos
const request = require('request');
const options = {
method: 'GET',
url: 'https://gate.whapi.cloud/groups?token=YOUR_API_TOKEN',
headers: {accept: 'application/json'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});
Contando o número de participantes no grupo do WhatsApp
request(options, function (error, response, body) {
if (error) throw new Error(error);
const groups = JSON.parse(body);
groups.forEach(group => {
console.log(`Group Name: ${group.name}`);
console.log(`Number of Participants: ${group.participants.length}`);
});
});
Gerenciando mensagens de grupo
app.post('/webhook', (req, res) => {
const message = req.body;
if (message.from.endsWith('@g.us')) {
// This is a group message
handleGroupMessage(message);
} else if (message.type === 'text') {
// Handle Text Messages
sendTextMessage(message.from, 'You said: ' + message.body);
}
res.status(200).end();
});
function handleGroupMessage(message) {
console.log(`Received a group message from ${message.from}: ${message.body}`);
// Further logic for group messages can be implemented here.
}
Teste e Depuração
- Baixe o ngrok e descompacte-o.
- Abra seu terminal e navegue até a pasta onde o ngrok está armazenado.
- Execute ./ngrok http NÚMERO_DA_PORTA, substituindo NÚMERO_DA_PORTA pela porta onde seu servidor Express está rodando localmente.
- Agora você deve ter um URL público que pode ser usado como URL de webhook em seu painel Whapi.Cloud.
Implantação e Hospedagem
- Instale o Heroku CLI e faça login.
- Navegue até o diretório do seu projeto e inicialize um repositório git, se ainda não tiver feito isso.
- Execute heroku create para criar um novo aplicativo Heroku.
- Envie seu código para o Heroku usando git push heroku master.
- Abra o painel do Heroku, vá até as configurações do aplicativo e adicione suas variáveis de ambiente, incluindo seu token de API do Whapi.Cloud.
- Finalmente, configure a URL do webhook no seu painel do Whapi.Cloud para a URL fornecida pelo Heroku.
Código-fonte de um bot de WhatsApp simples pronto para usar em Node.JS
module.exports = {
// API endpoint URL
apiUrl: "https://gate.whapi.cloud",
// API token from your channel
token: "YOUR CHANNEL TOKEN",
// The ID of the group to which we will send the message. Use to find out the ID: https://whapi.readme.io/reference/getgroups
group: '120363167596599603@g.us',
// The ID of the product we will send for the example. Create a product in your WhatsApp and find out the product ID: https://whapi.readme.io/reference/getproducts
product: '6559353560856703',
// Bot`s URL (for static file). Webhook Link to your server. At ( {server link}/messages ), when POST is requested, processing occurs
botUrl: "https://yoursite.com/messages"
}
const express = require('express');
const bodyParser = require('body-parser');
const fs = require('fs');
const fetch = require('node-fetch');
const FormData = require('form-data');
const config = require('./config.js');
process.on('unhandledRejection', err => {
console.log(err)
});
const COMMANDS = {
TEXT: 'Simple text message',
IMAGE: 'Send image',
DOCUMENT: 'Send document',
VIDEO: 'Send video',
CONTACT: 'Send contact',
PRODUCT: 'Send product',
GROUP_CREATE: 'Create group',
GROUP_TEXT: 'Simple text message for the group',
GROUPS_IDS: 'Get the id\'s of your three groups'
}
const FILES = {
IMAGE: './files/file_example_JPG_100kB.jpg',
DOCUMENT: './files/file-example_PDF_500_kB.pdf',
VIDEO: './files/file_example_MP4_480_1_5MG.mp4',
VCARD: './files/sample-vcard.txt'
}
/**
* Send request to Whapi.Cloud
* @param endpoint - endpoint path
* @param params - request body
* @param method - GET, POST, PATCH, DELETE
* @returns {Promise (object) }
*/
async function sendWhapiRequest(endpoint, params= {}, method = 'POST') {
let options = {
method: method,
headers: {
Authorization: `Bearer ${config.token}`
},
};
if (!params.media) options.headers['Content-Type'] = 'application/json';
let url = `${config.apiUrl}/${endpoint}`;
if(params && Object.keys(params).length > 0) {
if(method === 'GET')
url += '?' + new URLSearchParams(params);
else
options.body = params?.media ? toFormData(params) : JSON.stringify(params);
}
const response = await fetch(url, options);
let json = await response.json();
console.log('Whapi response:', JSON.stringify(json, null, 2));
return json;
}
/**
* Convert object to FormData
* @param obj
* @returns {FormData}
*/
function toFormData(obj) {
const form = new FormData();
for (let key in obj) {
form.append(key, obj[key]);
}
return form;
}
async function setHook() {
if (config.botUrl) {
/** type {import('./whapi').Settings} */
const settings = {
webhooks: [
{
url: config.botUrl,
events: [
// default event for getting messages
{type: "message", method: "post"}
],
mode: "method"
}
]
}
await sendWhapiRequest('settings', settings, 'PATCH');
}
}
async function handleNewMessages(req, res){
try {
/** type {import('./whapi').Message[]} */
const messages = req?.body?.messages;
for (let message of messages) {
if (message.from_me) continue;
/** type {import('./whapi').Sender} */
const sender = {
to: message.chat_id
}
let endpoint = 'messages/text';
const command = Object.keys(COMMANDS)[+message.text?.body?.trim() - 1];
switch (command) {
case 'TEXT': {
sender.body = 'Simple text message';
break;
}
case 'IMAGE': {
sender.caption = 'Text under the photo.';
sender.media = fs.createReadStream(FILES.IMAGE);
endpoint = 'messages/image';
break;
}
case 'DOCUMENT': {
sender.caption = 'Text under the document.';
sender.media = fs.createReadStream(FILES.DOCUMENT);
endpoint = 'messages/document';
break;
}
case 'VIDEO': {
sender.caption = 'Text under the video.';
sender.media = fs.createReadStream(FILES.VIDEO);
endpoint = 'messages/video';
break;
}
case 'CONTACT': {
sender.name = 'Whapi Test';
sender.vcard = fs.readFileSync(FILES.VCARD).toString();
endpoint = 'messages/contact';
break;
}
case 'PRODUCT': {
/* you can get real product id using endpoint https://whapi.readme.io/reference/getproducts */
endpoint = `business/products/${config.product}`;
break;
}
case 'GROUP_CREATE': {
/* Warning : you can create group only with contacts from phone contact list */
const res = await sendWhapiRequest(`groups`, {subject: 'Whapi.Cloud Test', participants: [message.chat_id.split('@')[0]]});
sender.body = res.group_id ? `Group created. Group id: ${res.group_id}` : 'Error';
break;
}
case 'GROUP_TEXT': {
/*To get group id, use /groups endpoint */
sender.to = config.group;
sender.body = 'Simple text message for the group';
break;
}
case 'GROUPS_IDS': {
const {groups} = await sendWhapiRequest('groups', {count: 3}, 'GET');
sender.body = groups && groups.reduce((prevVal, currVal, i) => {
return i === 0 ? `${currVal.id} - ${currVal.name}` : prevVal + ',\n ' + `${currVal.id} - ${currVal.name}`;
}, '') || 'No groups';
break;
}
default: {
sender.body = 'Hi. Send me a number from the list. Don\'t forget to change the actual data in the code! \n\n' +
Object.values(COMMANDS).map((text, i) => `${i + 1}. ${text}`).join('\n');
}
}
await sendWhapiRequest(endpoint, sender);
}
res.send('Ok');
} catch (e) {
res.send(e.message);
}
}
// Create a new instance of express
const app = express();
app.use(bodyParser.json());
app.get('/', function (req, res) {
res.send('Bot is running');
});
app.post('/messages', handleNewMessages);
setHook().then(() => {
const port = config.port || (config.botUrl.indexOf('https:') === 0 ? 443 : 80)
app.listen(port, function () {
console.log(`Listening on port ${port}...`);
});
});
- Inicializamos o servidor com Express e instalamos um webhook para lidar com mensagens recebidas.
- Quando uma mensagem de texto é recebida, o bot responde repetindo o texto recebido.
- Para enviar mensagens, usamos as funções sendTextMessage e sendImageMessage.

