Integración de WhatsApp en ChatGPT en 5 sencillos pasos (Guía práctica)

Este artículo ha sido actualizado por Benjamin Aronov en julio de 2025

Introducción

WhatsApp es el lugar donde mucha gente pasa el tiempo, ya sea chateando con amigos, familiares o incluso empresas. Y ChatGPT se ha convertido en una de las formas más sencillas de crear experiencias conversacionales; no solo en WhatsApp, sino también en Facebook Messenger también.

En este tutorial, te mostraremos cómo conectar los dos: cuando alguien envía un mensaje en WhatsApp, tu backend Python lo reenviará a ChatGPT, obtendrá una respuesta y la enviará de vuelta como respuesta; todo ello utilizando el sandbox de la API Messages API de Vonage y una sencilla aplicación Flask.

Es una forma útil de construir un asistente básico, probar ideas conversacionales o simplemente ver cómo encajan estas APIs. También mostraremos cómo extenderlo para enviar imágenes usando la API de generación de imágenes de OpenAI (DALL-E) como bonus.

Al final, tendrás un chatbot de WhatsApp funcional con el que podrás hablar utilizando tu número de sandbox.

Requisitos previos

En este tutorial, necesitarás los siguientes requisitos previos para integrar ChatGPT con WhatsApp:

• Cuenta API de Vonage

• Cuenta API OpenAI

• Python 3.9+

• Frasco

• ngrok

Vonage API Account

To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.

Ready to start building?

Experience seamless connectivity, real-time messaging, and crystal-clear voice and video calls—all at your fingertips.

Paso 1: Configurar el Sandbox de Messages API para WhatsApp

Inicie sesión en el Panel de control para desarrolladores de Vonage. Luego abre el Sandbox de mensajes.

Escanee el código QR para abrir WhatsApp y envíe el mensaje precargado. Una vez enviado el mensaje, se añadirá tu número de teléfono a la lista de permitidos.

A continuación, tendremos que configurar los webhooks para que el sandbox se conecte a nuestra app Flask. Para ello, tenemos ngrok. Así que abre tu terminal de línea de comandos y ejecuta:

ngrok http 3000

Ahora tienes tu URL ngrok que se parece a:

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

Así que ahora puedes actualizar los webhooks:

• Para Inbound: https://YOUR_NGROK_URL/inbound

• Por el estado: https://YOUR_NGROK_URL/status

Para obtener más ayuda, consulte Pruebas con ngrok.

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

¿Necesita ayuda con .env archivos? Consulta nuestra sección Introducción a las variables de entorno de Python para obtener más ayuda sobre la gestión segura de las claves API.

Paso 2: Cómo configurar una aplicación Flask

Ahora que tu sandbox está listo para enviar y recibir mensajes de WhatsApp, crea tu aplicación Flask, que se encargará de la lógica:

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

Cree un entorno virtual para la gestión segura de paquetes y entornos. Todos los comandos de terminal siguientes deben ejecutarse desde dentro del entorno virtual.

python3 -m venv venv
source venv/bin/activate

Cree nuestros archivos principales de Flask:

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

Instala las dependencias de nuestro proyecto:

pip install flask requests openai python-dotenv

Y guardarlos en nuestro archivo de requisitos:

pip freeze > requirements.txt

Añade tus credenciales de Vonage y OpenAI a tu archivo .env:

VONAGE_API_KEY=your_api_key
VONAGE_API_SECRET=your_secret

OPENAI_API_KEY=your_openai_key

>> Consulte la sección Introducción a las variables de entorno de Python Video para más ayuda.

A continuación, puede cargar sus variables de entorno de forma segura en el archivo config.py archivo. Además, aquí se concatenan y codifican tu clave y secreto de API de Vonage para poder autenticarte con la API de 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 último, en nuestro archivo main.py vamos a crear nuestro servidor Flask. Este servidor tiene dos endpoints /inbound y /statusque corresponden a los que configuraste anteriormente en tu sandbox. Así que cada vez que algo sucede en la aplicación de Vonage, que lo remitirá a su servidor Flask, y luego la lógica aquí se activará.

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)

Ahora puedes probar que el sandbox recibe tus mensajes y los reenvía a la aplicación Flask. En una pestaña separada de tu ngrok, ejecuta tu servidor Flask:

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

Y deberías ver tus mensajes registrados en el servidor.

Paso 3: Cómo recibir mensajes de WhatsApp en Flask

Ahora vamos a crear algo de lógica para analizar los mensajes entrantes de WhatsApp de Vonage, identificar al usuario y el contenido del mensaje, y enviar una respuesta en WhatsApp.

En primer lugar, vamos a crear un nuevo archivo para almacenar toda nuestra lógica:

touch chatbot_utils.py

Dentro de chatbot_utils.py añada lo siguiente:

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()

Y luego actualiza tu archivo main.py archivo para importar nuestras nuevas funciones, por debajo de las importaciones anteriores añadir:

from chatbot_utils import *

Y actualizar el /inbound en main.py para obtener ahora el remitente y usar nuestra función 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)

Ahora puede reiniciar su servidor Flask y probar el nuevo código. Debería repetirse la pregunta.

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

Paso 4: Llamar a la API de OpenAI y enviar una respuesta de WhatsApp

Nuestro último paso es llamar a la API de OpenAI, pasando el mensaje del usuario, y luego manejar la respuesta a WhatsApp.Dentro de chatbot_utils.py añade la siguiente función:

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()

Y ahora puede utilizarlo actualizando el /inbound punto final:

@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)

Paso 5: Pruebe su integración de ChatGPT y WhatsApp

Ahora puede (re)iniciar su servidor Flask:

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

Y envía una pregunta al número de teléfono de WhatsApp Sandbox. ¡Ahora recibirás una respuesta de ChatGPT!

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

Bonificación: Añadir generación de imágenes

¡Impresionante! Has añadido la generación de texto con un LLM usando el modelo GPT-4o de OpenAI. Pero también puedes generar y enviar imágenes AI usando el modelo DALL-E de OpenAI. Extendamos nuestra aplicación detectando cuando un usuario envía un prompt que comienza con "IMAGEN:"podemos llamar a DALL-E para que genere una imagen y se la envíe al usuario por WhatsApp con un pie de foto.

En su archivo chatbot_utils.py añada las dos funciones siguientes send_whatsapp_image y 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

Por último, tendremos que actualizar nuestro endpoint /inbound para descifrar si el usuario ha enviado una solicitud de imagen o una pregunta normal:

@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)

Arranca de nuevo tu servidor e intenta generar algunas imágenes de IA.

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

Conclusión

¡Buen trabajo! Construir con éxito un chatbot de WhatsApp que funcione y que se conecte a ChatGPT para obtener respuestas de texto natural e incluso genere imágenes utilizando DALL-E ha sido increíble. Este fue un gran punto de partida para experimentar con LLMs.

Desde aquí, puedes agregar indicaciones personalizadas al sistema, registrar las entradas del usuario para capacitación, manejar comandos más estructurados o incluso enviar mensajes a agentes humanos. La combinación de OpenAI y Messages API de Vonage abre muchas posibilidades.

También querrás salir de Sandbox y pasar a una aplicación completa de Vonage. Reemplaza las llamadas directas a la API con el SDK Python de Vonage para un mejor manejo de errores y capacidad de mantenimiento. Esto te permitirá agregar fácilmente la validación de los webhooks entrantes para garantizar que provengan realmente de Vonage, lo que evitará posibles vulnerabilidades de seguridad.

Si construyes algo guay, ¡queremos que nos lo cuentes! Únete a nosotros en el Slack para desarrolladores de Vonageo etiquétanos en X (antes Twitter).