Como enviar Mensagens de WhatsApp com Node.js e a API da ZENVIA

Aprenda como enviar mensagens de WhatsApp com Node.js e a API multicanal da ZENVIA de forma bastante fácil. Acompanhe nosso tutorial!

Enviar mensagens de WhatsApp com Node.js e a API multicanal da ZENVIA é bastante fácil. Além disso, é importante enfatizar que a utilização do WhatsApp Business API permite a aproximação com os clientes, assim como também é uma grande aliada na automatização de processos.

Por isso, vamos compartilhar um tutorial de envio de mensagens WhatsApp por meio da API multicanal em conjunto com o Node.js, um runtime que permite a execução de Javascript fora dos browsers. Isso possibilita executar processos assíncronos, proporcionando uma solução poderosa, robusta e escalável de envio de mensagens por WhatsApp.

Fora essas vantagens, a integração com a API multicanal da ZENVIA é, na prática, descomplicada. Neste artigo, você verá o passo a passo de dois métodos para começar a utilizar esta solução. Confira!

Passo a passo: enviando mensagens WhatsApp com Node.js

Para a execução do passo a passo que iremos demonstrar no artigo, estamos considerando que já exista uma conta criada no Sandbox da ZENVIA. Basta clicar no link, ir em “Criar Novo” e seguir as instruções. 

Mensagens Whatsapp com Node.js: como funciona?

Iniciando o primeiro passo, a API multicanal da ZENVIA ficará responsável pelo envio da mensagem para o usuário final. Isso acontecerá somente quando requisitado por um solicitante autenticado e, este, especificado o conteúdo e formato da mensagem.

Exemplo do fluxo da integração:

Preparativos para começarmos o envio de mensagens WhatsApp com Node.js

1. Verifique se em sua máquina há o Node.js através do comando abaixo no seu terminal:

$ node -v

Exemplo de saída:

v16.7.0

Caso sua saída não esteja alinhada com o exemplo, acesse o site oficial do Node.js para baixá-lo.

2. Também é  necessário ter uma conta na plataforma da ZENVIA, acesse aqui para fazer o login ou criar uma conta.

sandbox

Passo 1: Criando um token para sua conta

Para começar a utilizar a API, é necessário criar um token de autenticação, que deverá ser repassado em todas requisições, com o fim de certificar a autenticidade do solicitante.

1. Obtenha esse token através de Produtos > Desenvolvedores > Tokens e Webhooks.

2. Após isso, você será redirecionado para uma nova página. No campo Tokens, caso esteja vazio, clique em Criar Novo, e siga a instrução.

3. Copie o token e armazene-o em um arquivo .txt caso deseje, pois será fundamental para o desenvolvimento.

Passo 2: Selecionando a conta de WhatsApp

Para começar a enviar mensagens, é necessário ter uma identificação de sua conta que irá fazer os envios.

Dentro do Sandbox, é possível verificar em  Produtos > Desenvolvedores > Sandbox, e armazenar a Keyword do canal de WhatsApp em um arquivo.

Já para quem possuir uma conta WhatsApp oficial na ZENVIA, em geral, a identificação será o número de telefone da própria conta. De toda forma, pode-se verificar acessando Integrações > Canais conversacionais > Whatsapp > Gerenciar.

Na sequência:

Após isso, selecione a conta de WhatsApp que deseja e armazene o conteúdo do campo de Sender Id, pois ele será utilizado.

Passo 3: Mão no código

Agora que se tem o token, para autenticar a requisição e a conta do WhatsApp a serem utilizadas nos envios, resta fazer a chamada à API da ZENVIA via Node.js, simulando de uma forma simples uma situação comum em requisições por API.

Primeiro, é necessário criar o projeto:

$ mkdir zenvia-whatsapp-sender
$ cd zenvia-whatsapp-sender
$ npm init -y

Então, instale as bibliotecas Express.js para criar um servidor Node que chamará a API da ZENVIA, e o axios.js, para facilitar a requisição por HTTP para o serviço da ZENVIA.

$ npm add express axios

Com isso, já se cria o arquivo JavaScript com o seguinte código:

//zenvia-whatsapp.js
 
const express = require('express');
const axios = require('axios');
 
const app = express();
const PORT = 3000;
 
//token obtido na plataforma da Zenvia no Passo 1
const token = 'your_token';
 
//URL da api de whatsapp da Zenvia
const URL = 'https://api.zenvia.com/v2/channels/whatsapp/messages';
 
app.use(express.json());
 
app.post('/', async (req, res) => {
   const body = {
       from: 'your_senderId', //seu senderId obtido no Passo 2
       to: 'target_phone', //numero que vai receber a mensagem
       contents: [
           {
               type: 'text',
               text: 'Hello world from Zenvia'
           },
           {
               type: 'text',
               text: 'This a second message!’
           },
       ]  
   }
 
   try {
       const response = await axios.post(URL, body, {
           headers: {
               'X-API-TOKEN': token,
               'Content-Type': 'application/json',
           },
       });
 
       return res.send(response.data);
   } catch (error) {
       console.log(error);  
       return res.send('Ops! algo deu errado');
   }
});
 
app.listen(PORT, () => {
   console.log(`Up and ready at ${PORT}`)
});

No código acima, basicamente, se está criando um servidor RESTful rodando na porta 3000 da sua máquina local, que irá enviar a requisição para a API da ZENVIA, a partir da URL dela (https://api.zenvia.com/v2/channels/whatsapp/messages). O trecho mais importante é este:

//zenvia-whatsapp.js
 
app.post('/', async (req, res) => {
   const body = {
       from: 'your_senderId',//seu senderId obtido no Passo 2
       to: 'target_phone',//numero que vai receber a mensagem
       contents: [
           {
               type: 'text',
               text: 'Hello world from Zenvia'
           },
           {
               type: 'text',
               text: 'This a second message!’
           },
 
       ]  
   }
 
   try {
       const response = await axios.post(URL, body, {
           headers: {
               'X-API-TOKEN': token,
               'Content-Type': 'application/json',
           },
       });
 
       return res.send(response.data);
   } catch (error) {
       console.log(error);  
       return res.send('Ops! algo deu errado');
   }
});

Aqui, o corpo da requisição, armazenado na variável body, irá conter as informações fundamentais para o envio. Nele, deve estar contido principalmente: 

  • a identificação da sua conta WhatsApp (from);
  • o número de telefone que irá receber a mensagem (to);
  • os conteúdos que serão enviados (contents), sendo possivel enviar mais de uma mensagem em uma requisição ou outros tipos de mensagens como o template, location, file, button, contacts e entre outros, veja na Documentação todas possibilidades;

Então, junto com o body, será adicionado o cabeçalho da requisição (headers), contendo:

  • o token que foi obtido no passo 1 (X-API-TOKEN);
  • Content-Type, informando que a requisição é um JSON.

Assim fazendo uma requisição HTTP do tipo POST para a API, lembrando de usar async/await para isso.

Atenção!

Antes de prosseguir, vale elucidar que o tipo de mensagem template, quando utilizado, necessita da obtenção de um template que seja pré-aprovado pelo Whatsapp, saiba mais aqui.

Com isso, basta inicializar:

$ node zenvia-whatsapp.js

E fazer uma requisição POST para http://localhost:3000. Este deve ser seu retorno:

Tem como ficar ainda mais fácil: confira!

É possível facilitar ainda mais o uso com o sdk da ZENVIA:

$ npm add @zenvia/sdk 

Importe no arquivo:

const zenvia = require('@zenvia/sdk');

E no trecho do código do Passo 3, faça a substituição:

app.post('/',  async (req, res) => {
   const client = new zenvia.Client(token);
   const whatsapp = client.getChannel('whatsapp');
   const message = new zenvia.TextContent('Hello world from Zenvia');
  
   try {
       const response = await whatsapp.sendMessage('your_senderId', 'target_phone', message);
       return res.send(response);
   } catch (error) {
       console.log(error);
       return res.send('Ops! algo deu errado');
   }
 
});

Neste caso:

  • Será instanciado o cliente do sdk (variável client);
  • Em seguida especificar o canal (whatsapp);
  • Criar a mensagem (message);
  • E por fim enviar (sendMessage());

E… pronto!

Com isso, é possível enviar mensagens de WhatsApp, de maneira fácil, rápida e prática com os benefícios que o Node.js traz aliado ao empoderamento de comunicação de uma API com a da ZENVIA. Vamos colocar em prática nosso tutorial de WhatsApp com Node.js?

Se você quiser saber mais sobre outros tutoriais, confira também:

*Leonardo Nakashima é Desenvolvedor de Softwares na Zenvia | LinkedIn, GitHub

Categorias:
Escrito por

Leonardo Nakashima

Leia também

Fique por dentro e confira as nossas dicas sobre o mercado mobile e interação digital.