Integração do ChatGPT com o WhatsApp em 5 passos fáceis (guia prático)

Este artigo foi atualizado por Benjamin Aronov em julho de 2025

Introdução

O WhatsApp é onde muitas pessoas passam seu tempo, seja conversando com amigos, familiares ou até mesmo com empresas. E o ChatGPT se tornou uma das maneiras mais fáceis de criar experiências conversacionais; não apenas no WhatsApp, mas também no Facebook Messenger também.

Neste tutorial, vamos mostrar como conectar os dois: quando alguém enviar uma mensagem pelo WhatsApp, seu backend em Python irá encaminhá-la para o ChatGPT, obter uma resposta e enviá-la de volta como uma resposta; tudo isso usando o ambiente de testes da Messages API do Vonage e um aplicativo simples em Flask.

É uma maneira útil de criar um assistente básico, testar ideias de conversação ou simplesmente ver como essas APIs se integram. Como bônus, também mostraremos como ampliá-lo para enviar imagens usando a API de geração de imagens da OpenAI (DALL-E).

No final, você terá um chatbot do WhatsApp em funcionamento com o qual poderá interagir usando seu número de teste.

Pré-requisitos

Neste tutorial, você precisará dos seguintes pré-requisitos para integrar o ChatGPT ao WhatsApp:

• Account da API da Vonage

• Account da API da OpenAI

• Python 3.9 ou superior

• Frasco

• ngrok

Passo 1: Configurar o ambiente de teste da Messages API do WhatsApp

Faça login no Painel do Desenvolvedor da Vonage. Em seguida, abra o Sandbox de Mensagens.

Digitalize o código QR para abrir o WhatsApp e enviar a mensagem já preenchida. Assim que você enviar a mensagem, seu número de telefone será adicionado à lista de contatos autorizados.

Em seguida, você precisará configurar os webhooks para que o ambiente de teste se conecte ao nosso aplicativo Flask. Para isso, temos o ngrok. Então, abra o terminal de linha de comando e execute:

ngrok http 3000

Agora você tem sua URL do ngrok, que deve ser algo como:

Forwarding   https://ed95-77-137-44-66.ngrok-free.app 
-> http://localhost:3000

Então, agora você pode atualizar os webhooks:

• Para o Inbound: https://YOUR_NGROK_URL/inbound

• Para o status: https://YOUR_NGROK_URL/status

Para obter mais ajuda, consulte Testando com o ngrok. 

Configuring webhook URLs for inbound messages and status updates in the WhatsApp sandbox.

Precisa de ajuda com .env arquivos? Confira nosso Introdução às variáveis de ambiente do Python para obter mais orientações sobre como gerenciar chaves de API com segurança.

Etapa 2: Como configurar um aplicativo Flask

Agora que seu ambiente de teste está pronto para enviar e receber mensagens do WhatsApp, crie seu aplicativo Flask, que cuidará da lógica:

mkdir whatsapp-chatgpt-bot
cd whatsapp-chatgpt-bot

Crie um ambiente virtual para o gerenciamento seguro de pacotes e ambientes. Todos os comandos de terminal a seguir devem ser executados de dentro do ambiente virtual.

python3 -m venv venv
source venv/bin/activate

Vamos criar nossos arquivos principais do Flask:

touch main.py config.py .env requirements.txt

Instale as dependências do nosso projeto:

pip install flask requests openai python-dotenv

E salve-os em nosso arquivo de requisitos:

pip freeze > requirements.txt

Adicione suas credenciais da Vonage e OpenAI ao seu arquivo .env:

VONAGE_API_KEY=your_api_key
VONAGE_API_SECRET=your_secret

OPENAI_API_KEY=your_openai_key

>> Veja o Vídeo “Introdução às variáveis de ambiente do Python” para obter mais ajuda.

Você pode, então, carregar suas variáveis de ambiente com segurança no config.py arquivo. Além disso, aqui sua chave e seu segredo da API da Vonage são concatenados e codificados para permitir a autenticação na API da Vonage.

from dotenv import load_dotenv
import os
import base64

load_dotenv()

VONAGE_API_KEY = os.getenv("VONAGE_API_KEY")
VONAGE_API_SECRET = os.getenv("VONAGE_API_SECRET")
VONAGE_SANDBOX_NUMBER = 14157386102

credentials = f"{VONAGE_API_KEY}:{VONAGE_API_SECRET}"
encoded_credentials = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
VONAGE_AUTH_HEADER = f"Basic {encoded_credentials}"

VONAGE_URL = "https://messages-sandbox.nexmo.com/v1/messages"

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

Por fim, em nosso main.py arquivo, vamos criar nosso servidor Flask. Esse servidor tem dois endpoints, /inbound e /status, que correspondem aos que você configurou anteriormente na sua sandbox! Assim, sempre que algo acontecer no aplicativo da Vonage, ele encaminhará a solicitação para o seu servidor Flask, e então a lógica aqui será acionada.

import os
import json
import logging
from flask import Flask, request, Response
from config import *

app = Flask(__name__)
logging.basicConfig(format="%(message)s", level=logging.INFO)

@app.route('/status', methods=['POST'])
def message_status():
    data = request.get_json()
    logging.info(f"Status webhook received: {json.dumps(data)}")
    return Response(status=204)

@app.route('/inbound', methods=['POST'])
def inbound_message():
    data = request.get_json()
    logging.info(f"Inbound message: {json.dumps(data)}")

    return Response(status=200)

if __name__ == "__main__":
    port = int(os.environ.get("PORT", 3000))
    app.run(host="0.0.0.0", port=port)

Agora você pode verificar se a sandbox está recebendo suas mensagens e as encaminhando para o aplicativo Flask. Em uma aba separada do ngrok, execute seu servidor Flask:

chmod 666 main.py
export FLASK_ENV=development
export FLASK_APP=main.py
python3 main.py -p 3000

E você deverá ver suas mensagens registradas no servidor!

Etapa 3: Como receber mensagens do WhatsApp no Flask

Agora, vamos criar uma lógica para analisar as mensagens recebidas pelo WhatsApp provenientes da Vonage, identificar o usuário e o conteúdo da mensagem e enviar uma resposta pelo WhatsApp.

Primeiro, vamos criar um novo arquivo para armazenar toda a nossa lógica:

touch chatbot_utils.py

No interior chatbot_utils.py adicione o seguinte:

import os
import json
import requests
from   config import *
from openai import OpenAI

# OpenAI setup using SDK v1.x
client = OpenAI(api_key=OPENAI_API_KEY)

def send_whatsapp_text(to, text):
    payload = {
        "from": VONAGE_SANDBOX_NUMBER,
        "to": to,
        "channel": "whatsapp",
        "message_type": "text",
        "text": text
    }
    _post_to_vonage(payload)


def _post_to_vonage(payload):
    headers = {
        "Content-Type": "application/json",
        "Accept": "application/json",
        "Authorization": VONAGE_AUTH_HEADER
    }
    response = requests.post(VONAGE_URL, headers=headers, data=json.dumps(payload))
    response.raise_for_status()

Em seguida, atualize seu main.py arquivo para importar nossas novas funções; abaixo das importações anteriores, adicione: 

from chatbot_utils import *

E atualize o /inbound ponto de extremidade em main.py para agora obter o remetente e usar nossa função send_whatsapp_text: 

@app.route('/inbound', methods=['POST'])
def inbound_message():
    data = request.get_json()
    logging.info(f"Incoming message:\n{json.dumps(data, indent=2)}")

    try:
        sender = data['from']
        text = data.get('text', '').strip()

        if not text:
            logging.warning("No text in incoming message. Skipping.")
            return Response(status=204)

       response_text = f"I've received your question! You asked: \n \n {text}"
       send_whatsapp_text(sender, response_text)

    except Exception as e:
        logging.error(f"Error processing inbound message: {e}", exc_info=True)
        return Response("Error", status=500)

    return Response(status=200)

Agora você pode reiniciar seu servidor Flask e testar o novo código! Sua pergunta deve ser repetida para você.

A WhatsApp chat showing the Vonage Sandbox confirming receipt of a user's question about the meaning of life.

Etapa 4: Chamar a API da OpenAI e enviar uma resposta pelo WhatsApp

Nosso último passo é chamar a API da OpenAI, passando a mensagem do usuário, e, em seguida, processar a resposta no WhatsApp. Dentro chatbot_utils.py , adicione a seguinte função:

def generate_chatgpt_reply(prompt):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": prompt}
        ]
    )
    return response.choices[0].message.content.strip()

E agora você pode usá-lo atualizando o /inbound ponto de extremidade:

@app.route('/inbound', methods=['POST'])
def inbound_message():
    data = request.get_json()
    logging.info(f"Incoming message:\n{json.dumps(data, indent=2)}")

    try:
        sender = data['from']
        text = data.get('text', '').strip()

        if not text:
            logging.warning("No text in incoming message. Skipping.")
            return Response(status=204)

        # Generate reply using ChatGPT
        reply = generate_chatgpt_reply(text)
        logging.info(f"ChatGPT reply: {reply}")

        # Send response via WhatsApp
        send_whatsapp_text(sender, reply)

    except Exception as e:
        logging.error(f"Error processing inbound message: {e}", exc_info=True)
        return Response("Error", status=500)

    return Response(status=200)

Etapa 5: Teste a integração do ChatGPT com o WhatsApp

Agora você pode (re)iniciar seu servidor Flask:

chmod 666 main.py
export FLASK_ENV=development
export FLASK_APP=main.py
python3 main.py -p 3000

E envie uma pergunta para o número de telefone do WhatsApp Sandbox. Agora você receberá uma resposta do ChatGPT!

WhatsApp chatbot responds to a user question with a detailed explanation generated by ChatGPT.

Bônus: Adicionar geração de imagens

Que legal! Você adicionou a geração de texto com um LLM usando o modelo GPT-4o da OpenAI. Mas também é possível gerar e enviar imagens criadas por IA usando o modelo DALL-E da OpenAI. Vamos ampliar nosso aplicativo para detectar quando um usuário enviar um prompt que comece com “IMAGEM:”, podemos chamar o DALL-E para gerar uma imagem e, em seguida, enviá-la de volta ao usuário pelo WhatsApp com uma legenda. 

No seu chatbot_utils.py arquivo, adicione as duas funções a seguir, send_whatsapp_image e generate_image_from_prompt :

def send_whatsapp_image(to, image_url, caption="Image"):
    payload = {
        "from": VONAGE_SANDBOX_NUMBER,
        "to": to,
        "channel": "whatsapp",
        "message_type": "image",
        "image": {
            "url": image_url,
            "caption": caption
        }
    }
    _post_to_vonage(payload)


def generate_image_from_prompt(prompt):
    response = client.images.generate(
        model="dall-e-3",
        prompt=prompt,
        size="1024x1024",
        n=1
    )
    return response.data[0].url

E, por fim, precisaremos atualizar nosso /inbound ponto de extremidade para identificar se o usuário enviou uma solicitação de imagem ou uma pergunta comum: 

@app.route('/inbound', methods=['POST'])
def inbound_message():
    data = request.get_json()
    logging.info(f"Incoming message:\n{json.dumps(data, indent=2)}")

    try:
        sender = data['from']
        text = data.get('text', '').strip()

        if not text:
            logging.warning("No text in incoming message. Skipping.")
            return Response(status=204)

        if text.upper().startswith("IMAGE:"):
            prompt = text[6:].strip()
            logging.info(f"Image prompt: {prompt}")
            image_url = generate_image_from_prompt(prompt)
            send_whatsapp_image(sender, image_url, caption=prompt)
        else:
            reply = generate_chatgpt_reply(text)
            logging.info(f"ChatGPT reply: {reply}")
            send_whatsapp_text(sender, reply)

    except Exception as e:
        logging.error(f"Error processing inbound message: {e}", exc_info=True)
        return Response("Error", status=500)

    return Response(status=200)

Reinicie o servidor e tente gerar algumas imagens com IA!

A DALL·E-generated image sent in response to the prompt 'What is the meaning of life?' via Vonage WhatsApp Sandbox

Conclusão

Ótimo trabalho! Foi incrível conseguir criar um chatbot do WhatsApp que se conecta ao ChatGPT para gerar respostas em texto natural e até mesmo criar imagens usando o DALL-E! Esse foi um excelente ponto de partida para experimentar os LLMs.

A partir daqui, você pode adicionar prompts personalizados do sistema, registrar as entradas do usuário para treinamento, processar comandos mais estruturados ou até mesmo encaminhar mensagens para agentes humanos. A combinação da OpenAI com a Messages API da Vonage abre inúmeras possibilidades.

Você também vai querer sair do Sandbox e migrar para um aplicativo completo da Vonage. Substitua as chamadas diretas à API pelo SDK da Vonage para Python, a fim de obter melhor tratamento de erros e facilidade de manutenção. Isso permitirá que você adicione facilmente validação para os webhooks recebidos, garantindo que sejam realmente da Vonage e evitando possíveis vulnerabilidades de segurança.

Se você criar algo legal, queremos saber! Junte-se a nós no Slack dos desenvolvedores da Vonageou marque a gente no X (antigo Twitter).