Kevin Meneses
← Volver a artículos

Cómo automatizar interacciones y atención al cliente con APIs de redes sociales

APIPythonAutomationSocial Media
Cómo automatizar interacciones y atención al cliente con APIs de redes sociales

Publicar es un problema resuelto. Responder, no.

Cualquier programador de publicaciones lanza un post a seis redes. Luego llegan los comentarios en Instagram, entra un DM en Messenger, alguien pregunta por el envío en WhatsApp y aparece una reseña de 2 estrellas en Google. Cada uno vive en una app distinta, con una API distinta y con reglas distintas sobre cuándo puedes responder.

Si estás:

  • creando un SaaS que gestiona cuentas sociales para tus clientes,
  • llevando el soporte de una marca que vende por Instagram y WhatsApp,
  • o en una agencia que responde por una docena de clientes,

aquí es donde se van de verdad las horas de tu equipo.

(Si prefieres que un agente de IA se encargue también de publicar, lo expliqué en Cómo crear un agente de IA para redes sociales con Claude Code y Postproxy MCP.)


Por qué las interacciones son más difíciles de automatizar que las publicaciones

Publicar es saliente. Tú decides cuándo pasa.

Las interacciones son entrantes. Pasan cuando el cliente decide, en la plataforma que él eligió. Para automatizarlas con las APIs nativas necesitas:

  • La Graph API de Meta para comentarios de Instagram, comentarios de Facebook y Messenger
  • La WhatsApp Business Platform, con sus propias plantillas y números de teléfono
  • La Google Business Profile API para las reseñas
  • Las APIs de TikTok, YouTube y Threads para sus secciones de comentarios
  • Un receptor de webhooks para cada una, todas con payloads y firmas diferentes

Y luego las reglas. Meta solo te deja enviar mensajes libres dentro de las 24 horas siguientes al último mensaje del cliente. Una reseña de Google admite una sola respuesta. TikTok te deja fijar un comentario por vídeo.

La mayoría de equipos lo intenta, monta dos integraciones y vuelve a responder a mano.

El problema no son las respuestas.

Es que cada bandeja de entrada habla un idioma distinto.


El enfoque de una API unificada de interacciones

Una API unificada de redes sociales pone todas esas bandejas detrás de un mismo esquema. Postproxy es la que voy a usar aquí, porque su capa de interacciones va más allá que la mayoría: la misma API que publica tus posts gestiona también comentarios, mensajes directos (DMs) y reseñas.

Tres partes de la API hacen el trabajo:

  • Comments API: listar, responder, ocultar, borrar, dar like y fijar comentarios en Instagram, Facebook, Threads, YouTube, TikTok y Bluesky
  • Direct Messages API: chats y mensajes en Instagram, Facebook Messenger, WhatsApp, Telegram y Bluesky
  • Profile Comments API: reseñas de Google Business y recomendaciones de páginas de Facebook

Además, los webhooks avisan a tu servidor en el momento en que pasa algo: message.received, comment.created, profile_comment.created y decenas más.

👉 Puedes probar todo esto con el plan gratuito de Postproxy (10 posts al mes, sin tarjeta). Las interacciones como comentarios, DMs y respuestas son ilimitadas en los planes de pago.


La arquitectura

Esto es lo que vamos a construir:

Arquitectura de un bot de interacciones en redes sociales: los DMs llegan por webhook, un cron job recorre los comentarios y las reseñas, y todo lo dudoso pasa a una persona

Los DMs van por webhooks, porque en un chat el cliente espera respuesta en minutos. Los comentarios y las reseñas van por un polling corto: son menos urgentes y, de todas formas, las reseñas de Google solo se sincronizan cada hora.

La regla detrás de todo el diseño: automatiza lo obvio, escala el resto. Un bot que responde "¿hacéis envíos a México?" ahorra horas. Un bot que responde a un cliente enfadado empeora las cosas.


Paso 1. Registra un webhook

Los webhooks se registran desde la API. Suscríbete solo a los eventos que vas a gestionar:

import os
import requests

API = "https://api.postproxy.dev/api"
HEADERS = {
    "Authorization": f"Bearer {os.environ['POSTPROXY_API_KEY']}",
    "Content-Type": "application/json",
}

response = requests.post(
    f"{API}/webhooks",
    headers=HEADERS,
    json={
        "url": "https://your-app.com/webhooks/postproxy",
        "events": ["message.received", "comment.created", "profile_comment.created"],
        "description": "Engagement bot",
    },
)
response.raise_for_status()
print(response.json()["secret"])  # store it now, e.g. in POSTPROXY_WEBHOOK_SECRET

Guarda el secret en ese momento. Postproxy solo lo muestra al crearlo y cuando consultas ese webhook concreto, y lo necesitas para verificar cada entrega.


Paso 2. Recibe y verifica los eventos

Cada entrega lleva una cabecera X-Postproxy-Signature con el formato t=<timestamp>,v1=<hmac>. La firma es un HMAC-SHA256 de {timestamp}.{raw_body} con tu secret. Verifícala antes de fiarte de nada del payload.

Un receptor mínimo en Flask:

import hashlib
import hmac
import os

import requests
from flask import Flask, abort, request

app = Flask(__name__)
SECRET = os.environ["POSTPROXY_WEBHOOK_SECRET"]


def verify_webhook(payload: str, signature_header: str, secret: str) -> bool:
    parts = dict(p.split("=", 1) for p in signature_header.split(","))
    signed_payload = f"{parts['t']}.{payload}"
    computed = hmac.new(secret.encode(), signed_payload.encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(computed, parts["v1"])


@app.post("/webhooks/postproxy")
def postproxy_webhook():
    raw = request.get_data(as_text=True)
    signature = request.headers.get("X-Postproxy-Signature", "")
    if not signature or not verify_webhook(raw, signature, SECRET):
        abort(401)

    event = request.get_json()
    if event["type"] == "message.received":
        handle_message(event["data"]["object"])

    return "", 200

Devuelve un 2xx rápido. Postproxy espera respuesta en 30 segundos y reintenta una entrega fallida hasta 5 veces con backoff (1 minuto, 5 minutos, 30 minutos, 2 horas). Para cualquier cosa lenta, como una llamada a un LLM, manda el evento a una cola y responde al webhook al momento.


Paso 3. Responde a los DMs automáticamente, y sabe cuándo no hacerlo

Primero, un detalle de configuración que me costó unos minutos: los mensajes directos son opt-in en Postproxy. Hasta que los activas en app.postproxy.dev/chats, los endpoints de chat devuelven 422 con un mensaje que te dice justo eso.

Un evento message.received incluye el chat_id y el body del cliente. Es todo lo que necesitas para responder. Añade esto al mismo archivo que el receptor:

API = "https://api.postproxy.dev/api"
HEADERS = {
    "Authorization": f"Bearer {os.environ['POSTPROXY_API_KEY']}",
    "Content-Type": "application/json",
}

FAQ = {
    ("ship", "shipping", "envío", "envios"): "Yes, we ship worldwide. Orders leave within 48h.",
    ("return", "refund", "devolución"): "You have 30 days to return any order: https://shop.example.com/returns",
    ("hours", "open", "horario"): "Support is online Monday to Friday, 9:00 to 18:00 CET.",
}


def notify_human(item: dict) -> None:
    print("NEEDS A HUMAN:", item.get("body"))  # replace with Slack, email or your helpdesk


def classify(text: str) -> str | None:
    text = (text or "").lower()
    for keywords, answer in FAQ.items():
        if any(k in text for k in keywords):
            return answer
    return None


def handle_message(message: dict) -> None:
    answer = classify(message["body"])
    if answer is None:
        notify_human(message)
        return

    requests.post(
        f"{API}/chats/{message['chat_id']}/messages",
        headers=HEADERS,
        json={"body": answer},
    ).raise_for_status()

El envío devuelve 202 Accepted con status: "pending". La entrega es asíncrona y el resultado llega después como webhooks message.sent, message.delivered o message.failed.

El clasificador por palabras clave es tonto a propósito. Cambia classify() por una llamada a un LLM cuando se te quede corto, pero mantén el mismo contrato: devuelve una respuesta solo cuando estés seguro y None en caso contrario. Cada None va a una persona.

En Instagram y Messenger también puedes enviar respuestas rápidas, para que el cliente toque un botón en vez de escribir:

requests.post(
    f"{API}/chats/{chat_id}/messages",
    headers=HEADERS,
    json={
        "body": "What can I help with?",
        "quick_replies": [
            {"title": "Track order", "payload": "TRACK"},
            {"title": "Talk to support", "payload": "HELP"},
        ],
    },
)

Paso 4. La regla de las 24 horas (léela antes de lanzar nada)

Aquí es donde la mayoría de bots de interacciones acaban con cuentas restringidas.

Instagram y Facebook: Meta solo permite mensajes libres dentro de las 24 horas siguientes al último mensaje entrante del cliente. Pasado ese plazo, un agente humano aún puede responder durante 7 días enviando con "tag": "HUMAN_AGENT". Postproxy no controla el límite de 7 días: un mensaje tardío se pasa a Meta, Meta lo rechaza y acaba como failed.

Dos reglas para esa etiqueta:

  • Solo debe usarla una persona real. Nunca la pongas en mensajes del bot.
  • Nunca envíes contenido promocional con ella. La documentación de Postproxy avisa de que puede suspender la mensajería de tu página o de tu cuenta de Instagram.

WhatsApp: no hay etiqueta. Fuera de la ventana necesitas una plantilla aprobada. Cada chat lleva un flag within_messaging_window que puedes comprobar antes de enviar.

Telegram: no hay ventana, pero tu bot solo puede escribir a usuarios que le hayan escrito antes.

Bluesky: tampoco hay ventana, pero el destinatario tiene que tener los DMs activados.

Mete esto en el bot desde el primer día. Si llega un webhook de un chat de hace 3 días, el bot no debería responderlo. Debería hacerlo una persona.


Paso 5. Responde a los comentarios con una tarea programada

Los comentarios son menos urgentes que los DMs, así que un polling cada 15 minutos funciona bien. GET /api/comments devuelve los comentarios de todos tus posts, los más recientes primero, con el post_id y el profile_id que necesitas para responder.

Una trampa en la que caí al probarlo: el filtro from funciona sobre created_at, que es cuando Postproxy sincronizó el comentario, no cuando la persona lo escribió. Al conectar una cuenta, Postproxy importa sus comentarios existentes. En mi canal de YouTube, la primera sincronización trajo comentarios de 2020, todos con el created_at de hoy. Un bot que se fíe solo de from respondería a comentarios de hace cinco años en su primera ejecución.

Por eso el barrido comprueba también posted_at:

import json
from datetime import datetime, timedelta, timezone
from pathlib import Path

SEEN_FILE = Path("seen_comments.json")
OUR_USERNAMES = {"@acmeshop", "acme_shop"}  # as each platform shows it; YouTube adds "@"
MAX_AGE = timedelta(days=2)


def load_seen() -> set:
    return set(json.loads(SEEN_FILE.read_text())) if SEEN_FILE.exists() else set()


def is_recent(comment: dict) -> bool:
    if not comment["posted_at"]:
        return False
    posted = datetime.fromisoformat(comment["posted_at"].replace("Z", "+00:00"))
    return datetime.now(timezone.utc) - posted < MAX_AGE


def sweep_comments() -> None:
    seen = load_seen()
    since = (datetime.now(timezone.utc) - MAX_AGE).date().isoformat()
    response = requests.get(
        f"{API}/comments",
        headers=HEADERS,
        params={"from": since, "per_page": 100},
    )
    response.raise_for_status()

    for comment in response.json()["data"]:
        is_top_level = comment["parent_external_id"] is None
        is_ours = comment["author_username"] in OUR_USERNAMES
        if comment["id"] in seen or not is_top_level or is_ours or not is_recent(comment):
            continue

        answer = classify(comment["body"])
        if answer:
            requests.post(
                f"{API}/posts/{comment['post_id']}/comments",
                headers=HEADERS,
                params={"profile_id": comment["profile_id"]},
                json={"body": answer, "parent_id": comment["id"]},
            ).raise_for_status()
        else:
            notify_human(comment)

        seen.add(comment["id"])

    SEEN_FILE.write_text(json.dumps(sorted(seen)))

Cada comentario lleva también metadata, como follower_count e is_verified_user en Instagram. Sirve para enrutar: un comentario de una cuenta con 50k seguidores probablemente merece una persona.

Para el spam, POST /api/posts/:post_id/comments/:id/hide oculta un comentario sin borrarlo. Funciona en Instagram, Facebook, Threads y TikTok.

Y si una pregunta en público merece una respuesta en privado, Instagram y Facebook admiten una respuesta privada: un DM al autor del comentario, enviado con POST /api/posts/:post_id/comments/:id/private_reply. Tienes una por comentario, y funciona con comentarios de hasta 7 días.


Paso 6. Gestiona las reseñas de Google (con cuidado)

Las reseñas son lo más público que va a tocar tu bot. Trátalas de otra manera.

def sweep_reviews(profile_id: str) -> None:
    response = requests.get(
        f"{API}/profiles/{profile_id}/comments",
        headers=HEADERS,
        params={"per_page": 20},
    )
    response.raise_for_status()

    for review in response.json()["data"]:
        if review["replies"]:
            continue  # already answered

        stars = (review.get("platform_data") or {}).get("star_rating")
        if stars is None or stars <= 3:
            notify_human(review)  # never auto-reply to a bad review
            continue

        requests.post(
            f"{API}/profiles/{profile_id}/comments",
            headers=HEADERS,
            json={
                "parent_id": review["external_id"],
                "body": "Thank you for the review! We're glad you enjoyed it.",
            },
        ).raise_for_status()

Algunos detalles que la API gestiona y que, si no, descubrirías por las malas:

  • Las reseñas de Google pueden ser solo de estrellas, con body a null. El código de arriba no depende del texto.
  • Una reseña de Google admite una respuesta. Responder otra vez la actualiza.
  • Google puede rechazar una respuesta por motivos de políticas. platform_data.reply_state te dice si está en PENDING, APPROVED o REJECTED.
  • Nadie puede borrar una reseña desde la API, solo su propia respuesta. Es una regla de la plataforma.

Las reseñas positivas reciben un agradecimiento rápido. Todo lo que tenga 3 estrellas o menos va a una persona que pueda arreglar el problema de verdad.


Qué admite cada plataforma

No todas las acciones existen en todas partes. Este es el soporte de comentarios según la referencia de Postproxy:

AcciónInstagramFacebookThreadsBlueskyYouTubeTikTokLinkedIn
Listar✅✅✅✅✅✅Próximamente
Responder✅✅✅—✅✅Próximamente
Ocultar✅✅✅——✅Próximamente
Borrar✅✅——✅✅Próximamente
Fijar—————✅—

Llamar a una acción no admitida devuelve 405 Method Not Allowed, así que tu código puede intentarlo y recurrir a un plan B sin problemas.


Ideas clave

  • Las interacciones son un problema entrante y basado en eventos. Usa webhooks para los DMs y un polling corto para comentarios y reseñas.
  • Automatiza solo las preguntas que puedes responder con seguridad. Todo lo demás, y cada reseña mala, va a una persona.
  • Las reglas de las plataformas (ventana de 24h, HUMAN_AGENT, una respuesta por reseña) son parte del diseño, no casos raros.

La mayoría de marcas no pierden clientes por sus posts.

Los pierden en las respuestas que nadie envió.

👉 Crea tu bot de interacciones con Postproxy: una sola API para comentarios, DMs y reseñas en todas las plataformas, con un plan gratuito para empezar.