Arquitecto de automatización con IA: Día 46

Día 46. El reto de la mensajería: el mapa de canales y el coste real de WhatsApp

Introducción

Ayer, en el Día 45 (Sesión práctica de consolidación: migrar el escenario de Make a n8n), Valeria decidió con números qué procesos se quedaban en Make y cuáles pasaban a n8n, tradujo el escenario de pedidos a un workflow, lo comparó con los mismos mensajes y lo operó en modo sombra antes del corte, y Trigo Lento ganó un flujo de pedidos en su propio servidor y el presupuesto de los módulos 1 a 4 cerrado rubro por rubro. Hoy comienza el módulo 5/8: Ecosistema de comunicación: Gmail, Slack y WhatsApp API, en el que cada canal hablará con el cliente o con el equipo con una base registrada, un coste medido y una persona al mando de lo que tiene efecto económico o reputacional.

Es miércoles 18 de marzo, a media mañana. Valeria tiene abierto su cuaderno en la página del Día 33 (Sesión práctica: el escenario de pedidos de Trigo Lento, de punta a punta), donde una cifra quedó subrayada en rojo: $19.13$ USD al mes de mensajería de WhatsApp por Twilio frente a un rubro de $12$. El Día 21 (Sesión práctica: el mapa de automatización de Trigo Lento) ya había avisado de que el recargo de Twilio sobre las conversaciones rompería el presupuesto; el Día 26 (Laboratorio guiado en Make: el escenario de recordatorios de recogida, paso a paso) calculó $4.42$ USD de recordatorios de recogida solo para quien dio su consentimiento; y el Día 33 juntó las piezas y confirmó el diagnóstico: en Trigo Lento, la mensajería cuesta más que Make y la inteligencia artificial juntos. Aquel día terminó con una advertencia que hoy deja de ser una nota al pie: desde el 1 de octubre de 2026, Meta cobra también las respuestas dentro de la ventana de atención.

Don Ernesto lee la cifra por encima del hombro de su hija, con las manos todavía enharinadas, y no se calla: “Me dijo que lo caro era la inteligencia artificial y resulta que lo caro es mandar mensajitos.” Tiene razón, y conviene decirlo sin rodeos: Claude costó $0.74$ USD en el mes simulado del Día 33, y Twilio, más de veinticinco veces eso. La objeción no se responde con entusiasmo, sino con una factura desarmada línea por línea, porque el problema no es WhatsApp en sí, sino por qué puerta se entra a WhatsApp y quién cobra en cada una.

En la presente entrada, descubrirá cómo se ordena el ecosistema de comunicación de un negocio pequeño antes de automatizar un solo canal. Dibujará el mapa de canales de Trigo Lento con su dirección, su base de consentimiento, su volumen y su plataforma; aprenderá cómo cobra WhatsApp Business Platform por mensaje entregado, por categoría y por país, y qué cambia el 1 de octubre de 2026 con los mensajes de servicio. Reconstruirá los $19.13$ USD del Día 33 separando lo que cobra Meta de lo que cobra Twilio, comparará tres arquitecturas de acceso (la Cloud API de Meta directa desde n8n, Twilio y Wati) con su coste en los dos regímenes, estudiará la sensibilidad a las tarifas de México, tomará una decisión con una matriz ponderada y rehará el reparto de los $45$ USD. Al final, leerá el precio de cada mensaje en los webhooks de estado de la Cloud API, que es la forma de saber cada día, y no a fin de mes, cuánto se está gastando.

Objetivos de aprendizaje

Al terminar esta entrada, usted podrá:

• Explicar el modelo de cobro de WhatsApp Business Platform (por mensaje de plantilla entregado, por categoría y por país) y lo que cambia a partir del 1 de octubre de 2026 con los mensajes de servicio.
  
• Reconstruir el coste de mensajería del Día 33 y separar lo que cobra Meta de lo que cobra el proveedor.
  
• Comparar tres arquitecturas de acceso (Cloud API de Meta directa desde n8n, Twilio y Wati) con coste mensual, esfuerzo de operación y riesgo.
  
• Rehacer el reparto del presupuesto de 45 USD con la mensajería y la API de Claude como rubros principales.

El mapa de canales de Trigo Lento

Antes de hablar de tarifas conviene saber cuántas conversaciones tiene el negocio y por dónde entran. Un arquitecto que mira solo WhatsApp porque es el canal caro corre el riesgo de optimizar una pieza y romper otra: mover los recordatorios a SMS para “ahorrar” en WhatsApp, por ejemplo, multiplica el coste por veinte, como se verá en el Bloque 3. El mapa de canales responde cuatro preguntas por canal: quién escribe a quién (la dirección), con qué derecho (la base: el cliente escribió primero, hay consentimiento expreso o hay una relación comercial), cuánto (el volumen mensual) y con qué herramienta (la plataforma).

La base es la columna que más importa y la que más se olvida. La regla del módulo es estricta: ningún mensaje sale a un cliente sin una de dos bases registradas en consentimientos.json o en trigo_lento.sqlite. O el cliente escribió primero y la ventana de atención de $24$ horas está abierta, o hay consentimiento expreso para esa finalidad y se usa una plantilla aprobada por Meta en la categoría correcta. Las dos bases tienen además precios distintos, y por eso el mapa de canales es también el primer borrador de la factura.

El primer bloque fija las importaciones, la semilla global de la serie y los volúmenes del mes de ejemplo del Día 33: $1,535$ mensajes recibidos, $1,408$ respuestas libres dentro de la ventana y los recordatorios de recogida del Día 26, que salieron a $12.6$ por corrida en $26$ corridas al mes:

# Importaciones base, semilla de la serie, carpeta del día y supuestos fijos en Python:
import warnings
warnings.filterwarnings('ignore')
import json
from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Generador aleatorio con la semilla global de la serie:
rng = np.random.default_rng(2026)
pd.set_option('display.width', 120)
carpeta = Path('trigo_lento') / 'dia_46'
carpeta.mkdir(parents = True, exist_ok = True)

# Mes de ejemplo del Día 33 y supuestos de la serie (A.4.5, A.4.6 y A.5):
N_IN, N_OUT = 1_535, 1_408          # mensajes recibidos y respuestas libres en la ventana (Día 33)
N_PLANT = 26 * 12.6                  # recordatorios de recogida con plantilla de utilidad (Día 26)
PRESUPUESTO, RUBRO_WA = 45.00, 12.00
MXN_POR_USD = 18.50
print('numpy', np.__version__, '| pandas', pd.__version__)
print(f'Mes base: {N_IN} entrantes | {N_OUT} respuestas | {N_PLANT:.1f} recordatorios')

numpy 2.4.6 | pandas 3.0.3
Mes base: 1535 entrantes | 1408 respuestas | 327.6 recordatorios

Los recordatorios no son un número entero porque son una media: $26$ corridas por $12.6$ avisos de media, el $70%$ de consentimiento que supuso el Día 26 aplicado a $18$ encargos diarios. Mantener la cifra exacta, y no redondearla a $328$, tiene una razón práctica: con ella se reproducen al centavo los $4.42$ USD del Día 26 y los $19.13$ USD del Día 33.

Ahora el mapa completo como DataFrame. Los volúmenes de WhatsApp son los del Día 33; los de Instagram, el formulario y el teléfono salen del reparto de canales de la serie (Instagram recibe el $20%$ de los encargos, pero cada encargo trae varias idas y vueltas, de ahí los $400$ mensajes directos); los $300$ correos de mayoristas son los que medirá el Día 47 y los $900$ mensajes de Slack, una estimación de los avisos internos que el Día 50 convertirá en un canal de operaciones:

# Mapa de canales de Trigo Lento como DataFrame en Python:
canales = pd.DataFrame([
    ('WhatsApp', 'entrante', 'El cliente escribe primero', N_IN, 'Cloud API o Twilio'),
    ('WhatsApp', 'saliente', 'Ventana de 24 h abierta', N_OUT, 'Cloud API o Twilio'),
    ('WhatsApp', 'saliente', 'Consentimiento y plantilla de utilidad', round(N_PLANT), 'Cloud API o Twilio'),
    ('Instagram', 'entrante y saliente', 'El cliente escribe primero', 400, 'Bandeja de Meta'),
    ('Formulario web', 'entrante', 'Aviso de privacidad del formulario', 70, 'Make'),
    ('Teléfono', 'entrante', 'Llamada del cliente', 47, 'Persona'),
    ('Gmail mayoristas', 'entrante y saliente', 'Relación comercial y contrato', 300, 'n8n y Gmail'),
    ('Slack', 'interno', 'Equipo de Trigo Lento', 900, 'n8n y Slack'),
], columns = ['canal', 'direccion', 'base', 'mensajes_mes', 'plataforma'])
print(canales.to_string(index = False))
externos = canales[canales.direccion != 'interno'].mensajes_mes.sum()
whatsapp = canales[canales.canal == 'WhatsApp'].mensajes_mes.sum()
print(f'Mensajes con clientes al mes: {externos} | de WhatsApp: {whatsapp} ({whatsapp / externos:.1%})')

           canal           direccion                                   base  mensajes_mes         plataforma
        WhatsApp            entrante             El cliente escribe primero          1535 Cloud API o Twilio
        WhatsApp            saliente                Ventana de 24 h abierta          1408 Cloud API o Twilio
        WhatsApp            saliente Consentimiento y plantilla de utilidad           328 Cloud API o Twilio
       Instagram entrante y saliente             El cliente escribe primero           400    Bandeja de Meta
  Formulario web            entrante     Aviso de privacidad del formulario            70               Make
        Teléfono            entrante                    Llamada del cliente            47            Persona
Gmail mayoristas entrante y saliente          Relación comercial y contrato           300        n8n y Gmail
           Slack             interno                  Equipo de Trigo Lento           900        n8n y Slack
Mensajes con clientes al mes: 4088 | de WhatsApp: 3271 (80.0%)

El mapa tiene $4,088$ mensajes al mes con clientes, y el $80.0%$ son de WhatsApp. La Tabla 1 lo resume con el coste por mensaje de cada canal, que se calcula en los bloques siguientes.

Tabla 1. Mapa de canales de Trigo Lento: dirección, base, volumen mensual, plataforma y coste por mensaje (revisado en octubre de 2026).

Tres lecturas de la tabla ordenan el resto del módulo:

1. WhatsApp es el único canal que cobra por mensaje. Instagram, Gmail y Slack tienen costes de plataforma o de cuotas, pero no una tarifa por cada mensaje. Por eso el Día 46 se dedica a WhatsApp y los días 47 y 50 se ocupan de Gmail y de Slack sin calculadora de centavos.
   
2. Cada fila de WhatsApp tiene una base distinta y una tarifa distinta. Los mensajes entrantes nunca los cobra Meta; las respuestas dentro de la ventana eran gratuitas y dejan de serlo, en parte, desde octubre; los recordatorios usan plantilla y siempre se pagan. Mezclar las tres filas en un solo “mensajes de WhatsApp” es el error que hace incomprensible cualquier factura.
   
3. Slack es interno y su volumen no toca a los clientes. Que sea el canal con más mensajes después de WhatsApp no significa que sea un riesgo de coste: en el plan gratuito, con historial de $90$ días, cuesta $0$; el plan Pro cuesta $8.75$ USD por persona al mes en pago mensual y $7.25$ en pago anual según las fuentes consultadas en octubre de 2026, una cifra que el Día 50 pondrá frente al presupuesto.

Cómo cobra WhatsApp

WhatsApp Business Platform, la versión para empresas que se usa por API (no la aplicación WhatsApp Business del teléfono), cobra por mensaje entregado desde el 1 de julio de 2025. Antes cobraba por conversación de $24$ horas; hoy cada mensaje cuenta por separado, y solo si llega al teléfono del cliente. Tres variables fijan el precio de cada mensaje: si es una plantilla o un mensaje de servicio, la categoría de la plantilla y el país del número que lo recibe, no el del negocio.

Categorías y ventana de atención

Una plantilla es un mensaje con texto fijo y huecos para variables (el nombre de pila, el número de pedido, la hora), que Meta revisa y aprueba antes de que se pueda usar. Es la única forma de escribir a un cliente que no ha escrito en las últimas $24$ horas. Las plantillas se clasifican en tres categorías:

• Marketing: promociones, novedades, invitaciones a comprar. Es la categoría más cara y exige consentimiento expreso para recibir mensajes promocionales.
  
• Utilidad: avisos sobre una transacción en curso que el cliente pidió o espera, como la confirmación de un encargo o el recordatorio de recogida. Es la categoría de los avisos de Trigo Lento.
  
• Autenticación: códigos de un solo uso para iniciar sesión o confirmar una identidad. Trigo Lento no la usa.

Un mensaje de servicio es cualquier mensaje libre, sin plantilla, que el negocio envía mientras está abierta la ventana de atención al cliente: un plazo de $24$ horas que se abre, o se renueva, cada vez que el cliente escribe. Dentro de la ventana se conversa con libertad; cuando se cierra, solo se pueden enviar plantillas aprobadas. Los mensajes que el cliente envía al negocio nunca los cobra Meta.

El reloj de arena es la imagen que Valeria usa para explicarle la ventana a mostrador, y es la que muestra la Figura 1: se voltea cuando el cliente escribe, mientras corre la arena se conversa libremente y, cuando se vacía, solo pasan las plantillas.

Figura 1. La ventana de atención de 24 horas como reloj de arena: se voltea cuando el cliente escribe; mientras corre, se conversa libremente (sin tarifa de Meta hasta el 30 de septiembre de 2026, a 0.0085 USD desde la respuesta 1 001 del mes a partir del 1 de octubre); al vaciarse, solo pasan plantillas aprobadas.

Hay además dos casos especiales que conviene conocer aunque Trigo Lento no los use todavía. El primero es la ventana gratuita de los puntos de entrada: si el cliente llega por un anuncio que lleva a WhatsApp o por el botón de WhatsApp de la página de Facebook y el negocio responde en $24$ horas, Meta no cobra ningún mensaje durante un periodo más largo. La Tabla C de la serie lo fija en $72$ horas; la página de Meta consultada en octubre de 2026 dice que esa ventana puede permanecer abierta hasta $7$ días. Las fuentes no coinciden, y como Trigo Lento no compra anuncios, el cálculo de hoy no cuenta con ella. El segundo son los escalones de volumen: las tarifas de utilidad y de autenticación bajan cuando una empresa supera ciertos volúmenes mensuales, que se suman en todo el portafolio del negocio y se reinician cada mes. Con algunos cientos de plantillas al mes, Trigo Lento paga siempre la tarifa de lista.

Lo que cambia el 1 de octubre de 2026

Hasta el 30 de septiembre de 2026 rigen dos gratuidades que explican por qué la mensajería con la Cloud API parecía casi gratis en el Día 21: los mensajes de servicio dentro de la ventana no tienen tarifa de Meta, y las plantillas de utilidad enviadas dentro de una ventana abierta tampoco. Desde el 1 de octubre de 2026, según la página de precios de Meta revisada en octubre de 2026 y el aviso de Twilio sobre los cambios de precios de WhatsApp:

• Los mensajes de servicio se cobran a la tarifa de utilidad, con una franquicia de $1,000$ mensajes de servicio entregados al mes por número de teléfono del negocio. Meta cobra a partir del mensaje $1,001$, y lo que no se usa en un mes no pasa al siguiente.
  
• Las plantillas de utilidad dentro de la ventana se cobran, a su tarifa normal y sin franquicia.
  
• Las plantillas de marketing, de autenticación y de utilidad fuera de la ventana se siguen cobrando como antes, y las tarifas de marketing de siete mercados, México entre ellos, suben ese mismo día.

Cuando se planificó este módulo, la página de Meta todavía describía el servicio dentro de la ventana como gratuito y solo Twilio y fuentes secundarias anunciaban el cambio; en la revisión de octubre de 2026 la página de Meta ya lo describe, y en los webhooks de estado el tipo de precio de esas plantillas pasa de free_customer_service a regular. La regla, por tanto, coincide entre fuentes. Lo que no coincide son las cifras, y eso lo resuelve el siguiente bloque, que guarda cada tarifa con su fuente y una columna que dice si las fuentes discrepan:

# Tarifas de mensajería con fuente, fecha de revisión y aviso de discrepancia en Python:
REVISION = 'octubre de 2026'
tarifas = pd.DataFrame([
    ('meta_utilidad_mx', 0.0085, 'Meta (tarjeta 1-oct-2026) y Tabla C', 'sí', 'otra fuente: 0.0040'),
    ('meta_servicio_mx', 0.0085, 'Meta, desde el 1-oct-2026', 'no', 'antes: 0; 1 000 gratis al mes'),
    ('meta_marketing_mx', 0.0397, 'Fuentes secundarias, 1-oct-2026', 'sí', 'Tabla C: 0.0305; otra: 0.0378'),
    ('meta_autenticacion_mx', 0.0085, 'Fuentes secundarias, 1-oct-2026', 'sí', 'otra fuente: 0.0172'),
    ('twilio_por_mensaje', 0.0050, 'Página de Twilio, sept. 2026', 'no', 'entrante o saliente'),
    ('twilio_fallido', 0.0010, 'Página de Twilio, sept. 2026', 'no', 'solo estado fallido'),
    ('wati_growth_anual', 59.00, 'Fuentes secundarias', 'sí', '69 en pago mensual'),
    ('wati_recargo', 0.20, 'Fuentes secundarias', 'sí', 'otra fuente: 0.60 a 0.80'),
    ('sms_twilio_mx', 0.1819, 'Página de Twilio', 'sí', 'otra página: 0.1511'),
], columns = ['concepto', 'valor', 'fuente', 'fuentes_no_coinciden', 'nota'])
T = dict(zip(tarifas.concepto, tarifas.valor))
print(f'Revisado en {REVISION}')
print(tarifas.to_string(index = False))
print('Conceptos con fuentes que no coinciden:', int((tarifas.fuentes_no_coinciden == 'sí').sum()), 'de', len(tarifas))

# Coste de un recordatorio de recogida según el canal, por mensaje y en el mes base:
por_recordatorio = pd.Series({'WhatsApp por Cloud API': T['meta_utilidad_mx'],
                              'WhatsApp por Twilio': T['meta_utilidad_mx'] + T['twilio_por_mensaje'],
                              'SMS por Twilio': T['sms_twilio_mx'], 'Correo electrónico': 0.0})
print(pd.DataFrame({'por_mensaje': por_recordatorio, 'al_mes': por_recordatorio * N_PLANT}).round(4).to_string())

Revisado en octubre de 2026
             concepto   valor                              fuente fuentes_no_coinciden                          nota
     meta_utilidad_mx  0.0085 Meta (tarjeta 1-oct-2026) y Tabla C                   sí           otra fuente: 0.0040
     meta_servicio_mx  0.0085           Meta, desde el 1-oct-2026                   no antes: 0; 1 000 gratis al mes
    meta_marketing_mx  0.0397     Fuentes secundarias, 1-oct-2026                   sí Tabla C: 0.0305; otra: 0.0378
meta_autenticacion_mx  0.0085     Fuentes secundarias, 1-oct-2026                   sí           otra fuente: 0.0172
   twilio_por_mensaje  0.0050        Página de Twilio, sept. 2026                   no           entrante o saliente
       twilio_fallido  0.0010        Página de Twilio, sept. 2026                   no           solo estado fallido
    wati_growth_anual 59.0000                 Fuentes secundarias                   sí            69 en pago mensual
         wati_recargo  0.2000                 Fuentes secundarias                   sí      otra fuente: 0.60 a 0.80
        sms_twilio_mx  0.1819                    Página de Twilio                   sí           otra página: 0.1511
Conceptos con fuentes que no coinciden: 6 de 9
                        por_mensaje   al_mes
WhatsApp por Cloud API       0.0085   2.7846
WhatsApp por Twilio          0.0135   4.4226
SMS por Twilio               0.1819  59.5904
Correo electrónico           0.0000   0.0000

Seis de los nueve conceptos tienen fuentes que no coinciden. La tarifa que más pesa en Trigo Lento, la de utilidad en México, es la más firme: $0.0085$ USD en la tarjeta de Meta efectiva el 1 de octubre de 2026 según dos fuentes, el mismo valor que usa la Tabla C de la serie desde el Día 12; solo una guía de terceros, sin fecha de vigencia, da $0.0040$. La tarifa de marketing tiene tres valores ($0.0305$, $0.0378$ y $0.0397$ USD), y el recargo de Wati tiene dos lecturas muy distintas, del $20%$ al $80%$ sobre Meta. La Tabla 2 las reúne.

Tabla 2. Tarifas de mensajería que usa la entrada, con su fuente y su discrepancia (USD, revisado en octubre de 2026).

La última parte de la salida responde a la tentación de “salirse” de WhatsApp para los recordatorios. Un recordatorio cuesta $0.0085$ USD por la Cloud API, $0.0135$ por Twilio y $0.1819$ por SMS: con los $327.6$ recordatorios del mes, $2.78$ USD frente a $59.59$ USD. El correo no cuesta nada por mensaje, pero un recordatorio de recogida que llega al buzón de promociones no cumple su función. WhatsApp no es el canal caro; el recargo por mensaje es lo caro, y eso depende de la puerta, no del canal.

La idea completa del cobro cabe en un taxímetro con dos casetas, como muestra la Figura 2: cada mensaje que sale cruza primero la del proveedor, si lo hay, y después la de Meta, y cada caseta tiene su propia tarifa y sus propias excepciones.

Figura 2. El taxímetro del mensaje: cada mensaje cruza la caseta del proveedor y la de Meta; Twilio cobra 0.005 USD por mensaje entrante o saliente, Meta cobra las plantillas y, desde octubre, las respuestas que pasan de 1 000 al mes; con la Cloud API directa la primera caseta no existe.

Lea la figura de izquierda a derecha y fíjese en los tres caminos que no pagan nada. Un mensaje entrante cruza la caseta del proveedor (Twilio cobra $0.005$ USD también por recibir) pero nunca la de Meta. Una respuesta dentro de la ventana, antes de octubre, solo pagaba la caseta del proveedor. Y con la Cloud API directa no hay primera caseta: Meta es el único que cobra.

Tres maneras de conectarse

WhatsApp Business Platform no se contrata como una aplicación, se contrata una forma de acceso a la API. Hay tres maneras, y todas entregan el mismo mensaje al mismo teléfono con la misma tarifa de Meta; lo que cambia es quién se pone en medio, qué cobra y qué hace por usted:

• Cloud API de Meta directa. El negocio crea su cuenta de WhatsApp Business en el administrador de Meta, verifica la empresa, registra su número y recibe los mensajes en un webhook propio. En Trigo Lento, ese webhook es el n8n que el módulo 4 instaló en su servidor. No hay recargo por mensaje: solo se pagan las tarifas de Meta. A cambio, todo lo demás lo opera el negocio: el webhook, la firma de las peticiones, los reintentos, la bandeja para atender a mano y la renovación del token de acceso.
  
• Twilio. Es un proveedor de soluciones de negocio (BSP, por sus siglas en inglés: “Business Solution Provider”) que pone su consola, su SDK y su infraestructura entre el negocio y Meta. Es la puerta que Trigo Lento usa desde el Día 23: verifica la firma X-Twilio-Signature, reenvía los mensajes al webhook y cobra $0.005$ USD por cada mensaje enviado o recibido, más $0.001$ USD por cada mensaje que termina en estado fallido.
  
• Wati. Es otro proveedor, orientado a negocios que quieren una bandeja compartida para varias personas, difusiones, un constructor de respuestas automáticas y un catálogo, sin programar. No tiene plan gratuito: el plan Growth cuesta $59$ USD al mes en pago anual ($69$ en mensual), y los mensajes se cobran con un recargo sobre la tarifa de Meta que las fuentes no describen igual.

Las tres puertas se parecen a tres formas de entrar a un edificio, como muestra la Figura 3: una puerta propia con llave propia, un portero que cobra por cada visita y un edificio con recepción que cobra renta mensual.

Figura 3. Las tres puertas a WhatsApp: la Cloud API directa es una puerta propia con llave propia (6.25 USD al mes), Twilio un portero que cobra cada visita (22.61 USD) y Wati un edificio con recepción y renta mensual (66.50 USD), con el mes de ejemplo y el régimen desde el 1 de octubre de 2026.

La Tabla 3 compara las tres puertas en lo que importa a Trigo Lento.

Tabla 3. Cloud API directa, Twilio y Wati: recargo, cuota fija, operación y riesgo de dependencia (precios revisado en octubre de 2026).

La tabla no tiene una columna ganadora en todo. La Cloud API gana en coste y en dependencia, pierde en operación; Wati es justo al revés. Por eso la decisión necesita los números de la siguiente sección y una matriz ponderada al final.

El coste en los dos regímenes

Con las tarifas fijadas, el coste mensual de la mensajería se escribe en una sola fórmula que vale para las tres puertas y los dos regímenes:

$$ C = \underbrace{(n_{in} + n_{out} + n_{plant}) \cdot r_p}{\text{proveedor}} + \underbrace{\delta \cdot \max(0,\ n{out} - F) \cdot r_u + n_{plant} \cdot r_u}_{\text{Meta}} + c_f $$

La lógica:

• $n_{in}$, $n_{out}$ y $n_{plant}$ son los mensajes recibidos, las respuestas libres dentro de la ventana y las plantillas de utilidad del mes: $1,535$, $1,408$ y $327.6$ en el mes de ejemplo.
  
• $r_p$ es el recargo del proveedor por mensaje, enviado o recibido: $0.005$ USD en Twilio y $0$ en la Cloud API directa.
  
• $r_u$ es la tarifa de utilidad de Meta en México, $0.0085$ USD, que desde el 1 de octubre de 2026 se aplica también a los mensajes de servicio.
  
• $F = 1,000$ es la franquicia mensual de mensajes de servicio por número, y $\delta$ vale $0$ en el régimen anterior (hasta el 30 de septiembre de 2026) y $1$ en el nuevo: solo las respuestas que pasan de mil se cobran.
  
• $c_f$ es la cuota fija del proveedor: $0$ en la Cloud API y en Twilio, $59$ USD en Wati Growth, que además cobra un porcentaje sobre la parte de Meta en lugar de $r_p$.

Una consecuencia se lee antes de calcular nada: la diferencia entre Twilio y la Cloud API no depende del régimen, porque la parte de Meta es la misma en las dos puertas:

$$ \Delta C = C_{Twilio} - C_{Cloud} = r_p \cdot (n_{in} + n_{out} + n_{plant}) $$

Con los volúmenes del mes, $\Delta C = 0.005 \cdot 3,270.6 = 16.35$ USD. El cambio de octubre sube por igual las dos puertas; lo que las separa es el recargo sobre cada mensaje de la conversación, incluidos los que el cliente envía.

La función coste_mensajeria traduce la fórmula a Python, devuelve por separado lo que cobra Meta y lo que cobra el proveedor, y el bloque la aplica a las seis combinaciones de arquitectura y régimen:

# Coste mensual por arquitectura y régimen de cobro en Python:
FRANQUICIA = 1_000          # mensajes de servicio gratuitos al mes por número desde el 1-oct-2026

def coste_mensajeria(arquitectura, regimen, n_in, n_out, n_plant, tarifas, recargo_wati = None):
    # Devuelve (lo que cobra Meta, lo que cobra el proveedor) en USD al mes:
    r_u = tarifas['meta_utilidad_mx']
    meta = n_plant * r_u
    if regimen == 'nuevo':
        meta += max(0, n_out - FRANQUICIA) * tarifas['meta_servicio_mx']
    if arquitectura == 'Cloud API':
        proveedor = 0.0
    elif arquitectura == 'Twilio':
        proveedor = (n_in + n_out + n_plant) * tarifas['twilio_por_mensaje']
    else:   # Wati: cuota fija más un recargo porcentual sobre lo que cobra Meta
        recargo = tarifas['wati_recargo'] if recargo_wati is None else recargo_wati
        proveedor = tarifas['wati_growth_anual'] + meta * recargo
    return round(meta, 4), round(proveedor, 4)

filas = []
for arq in ['Cloud API', 'Twilio', 'Wati']:
    for reg in ['anterior', 'nuevo']:
        meta, prov = coste_mensajeria(arq, reg, N_IN, N_OUT, N_PLANT, T)
        filas.append((arq, reg, meta, prov, meta + prov))
tabla3 = pd.DataFrame(filas, columns = ['arquitectura', 'regimen', 'meta', 'proveedor', 'total']).round(2)
tabla3['cabe_en_12'] = np.where(tabla3.total <= RUBRO_WA, 'sí', 'no')
print(tabla3.to_string(index = False))

fig, ax = plt.subplots(figsize = (11, 5.2))
etiquetas = [f'{a}\n{"hasta 30-sep" if r == "anterior" else "desde 1-oct"}' for a, r in zip(tabla3.arquitectura, tabla3.regimen)]
x = np.arange(len(tabla3))
ax.bar(x, tabla3.meta, color = '#2a78d6', label = 'Tarifa de Meta')
ax.bar(x, tabla3.proveedor, bottom = tabla3.meta, color = '#eb6834', label = 'Proveedor (recargo o cuota)')
for xi, t in zip(x, tabla3.total):
    if t < 30:
        ax.text(xi, t + 0.6, f'{t:.2f}', ha = 'center', fontsize = 10)
    else:   # Wati no cabe en la escala: barra recortada y cifra dentro
        ax.text(xi, 28, f'{t:.2f}\n(recortada)', ha = 'center', fontsize = 10, color = 'white')
ax.axhline(RUBRO_WA, color = '#c8423b', linestyle = '--', linewidth = 1.5)
ax.text(-0.4, RUBRO_WA + 0.5, 'Rubro: 12 USD', color = '#c8423b', ha = 'left', fontsize = 10)
ax.set_ylim(0, 32)
ax.set_xticks(x, etiquetas, fontsize = 9)
ax.set_ylabel('USD al mes')
ax.set_title('Coste mensual de WhatsApp por arquitectura y régimen', fontsize = 16)
ax.legend(loc = 'upper left', bbox_to_anchor = (0.0, 0.92), frameon = False)
ax.grid(axis = 'y', color = '#e6e5e1')
ax.set_axisbelow(True)
plt.tight_layout()
plt.show()

arquitectura  regimen  meta  proveedor  total cabe_en_12
   Cloud API anterior  2.78       0.00   2.78         sí
   Cloud API    nuevo  6.25       0.00   6.25         sí
      Twilio anterior  2.78      16.35  19.14         no
      Twilio    nuevo  6.25      16.35  22.61         no
        Wati anterior  2.78      59.56  62.34         no
        Wati    nuevo  6.25      60.25  66.50         no

La Tabla 4 pone las seis cifras en limpio.

Tabla 4. Coste mensual de WhatsApp por arquitectura y régimen con el mes de ejemplo del Día 33 (USD, revisado en octubre de 2026).

La gráfica hace visible lo que la tabla dice con números: la parte azul, la de Meta, es idéntica en las tres puertas dentro de cada régimen ($2.78$ USD antes y $6.25$ USD después del cambio); lo que cambia de una puerta a otra es la parte naranja. Con Twilio, el proveedor se lleva $16.35$ USD, casi seis veces lo que cobra Meta; con Wati, la cuota fija por sí sola ya es cinco veces el rubro. La Cloud API directa es la única que cabe en los $12$ USD en los dos regímenes, y con el cambio de octubre todavía deja $5.75$ USD de margen.

La factura de 19.13 USD, línea por línea

Don Ernesto no se fía de una tabla que dice que la misma mensajería puede costar $2.78$ o $19.14$ USD. Quiere ver de dónde sale la cifra del Día 33, que es la que lleva dos semanas subrayada. Con la función coste_mensajeria ya escrita, la reconstrucción es una línea, y una aserción de igualdad vale más que cualquier explicación.

El siguiente bloque desarma la factura de Twilio en sus cuatro líneas, comprueba con una aserción que el total coincide con el Día 33 y calcula también el volumen de diseño de la serie (A.5): $1,560$ mensajes recibidos, otras tantas respuestas y $468$ recordatorios, como si todos los clientes dieran su consentimiento:

# Reconstrucción de los 19.13 USD del Día 33 y del volumen de diseño en Python:
meta, prov = coste_mensajeria('Twilio', 'anterior', N_IN, N_OUT, N_PLANT, T)
recordatorios_dia_26 = N_PLANT * (T['meta_utilidad_mx'] + T['twilio_por_mensaje'])
desglose = pd.Series({
    'Twilio por recibir (1 535 x 0.005)': N_IN * T['twilio_por_mensaje'],
    'Twilio por responder (1 408 x 0.005)': N_OUT * T['twilio_por_mensaje'],
    'Twilio por los recordatorios (327.6 x 0.005)': N_PLANT * T['twilio_por_mensaje'],
    'Meta por los recordatorios (327.6 x 0.0085)': N_PLANT * T['meta_utilidad_mx'],
}).round(4)
print(desglose.to_string())
print(f'Recordatorios del Día 26: {recordatorios_dia_26:.4f} USD (el Día 33 usó 4.42 redondeado)')
dia_33 = N_IN * 0.005 + N_OUT * 0.005 + 4.42
assert abs((meta + prov) - dia_33) < 0.01, 'La reconstrucción no coincide con el Día 33'
print(f'Exacto: {meta + prov:.4f} | Día 33: {dia_33:.3f} -> 19.13 | diferencia: {meta + prov - dia_33:.4f} USD')
print(f'Proveedor: {prov:.2f} USD ({prov / (meta + prov):.1%}) | Meta: {meta:.2f} USD ({meta / (meta + prov):.1%})')

# Volumen de diseño del plan (A.5): todo cliente responde y todo encargo lleva recordatorio:
diseno = {}
for arq in ['Twilio', 'Cloud API']:
    for reg in ['anterior', 'nuevo']:
        diseno[f'{arq} {reg}'] = round(sum(coste_mensajeria(arq, reg, 1_560, 1_560, 468, T)), 2)
print('Volumen de diseño (1 560 / 1 560 / 468):', diseno)

Twilio por recibir (1 535 x 0.005)              7.6750
Twilio por responder (1 408 x 0.005)            7.0400
Twilio por los recordatorios (327.6 x 0.005)    1.6380
Meta por los recordatorios (327.6 x 0.0085)     2.7846
Recordatorios del Día 26: 4.4226 USD (el Día 33 usó 4.42 redondeado)
Exacto: 19.1376 | Día 33: 19.135 -> 19.13 | diferencia: 0.0026 USD
Proveedor: 16.35 USD (85.4%) | Meta: 2.78 USD (14.6%)
Volumen de diseño (1 560 / 1 560 / 468): {'Twilio anterior': 21.92, 'Twilio nuevo': 26.68, 'Cloud API anterior': 3.98, 'Cloud API nuevo': 8.74}

La aserción pasa: la cifra exacta es $19.1376$ USD y la del Día 33, $19.13$. La diferencia de $0.0026$ USD no es un error, es el redondeo: el Día 33 sumó los recordatorios del Día 26 como $4.42$ USD redondeados, y el cálculo de hoy usa los $4.4226$ exactos. En una factura real, el proveedor redondea cada mensaje o cada línea según sus propias reglas, y una diferencia de un centavo entre la estimación y la factura es normal.

Lo importante está en las dos últimas líneas de la primera parte. El $85.4%$ de la factura es de Twilio y solo el $14.6%$ es de Meta. Las líneas más grandes no son los recordatorios, que son lo único que Meta cobraba en marzo, sino los $7.68$ USD por recibir los $1,535$ mensajes y los $7.04$ USD por responder las $1,408$ veces. Cada “gracias” de una clienta, cada “¿a qué hora abren?” y cada respuesta de Valeria escrita a mano desde el mismo número pagan medio centavo de dólar en la caseta de Twilio.

El volumen de diseño da las cifras que la serie anticipó al planificar el módulo: $21.92$ USD con Twilio en el régimen anterior, $26.68$ en el nuevo, $3.98$ con la Cloud API antes del cambio y $8.74$ después. El volumen de diseño es más exigente que el mes de ejemplo porque supone que cada cliente responde y que todos aceptan los recordatorios, y aun así la Cloud API cabe en el rubro y Twilio no.

Cuánto aguanta cada puerta si el negocio crece

Una decisión de arquitectura no se toma con el volumen de hoy, sino con el de dentro de un año. El siguiente bloque recorre de $500$ a $4,000$ mensajes entrantes al mes, mantiene la proporción de respuestas del mes de ejemplo ($1,408$ por cada $1,535$) y calcula las tres curvas en el régimen nuevo:

# Coste mensual frente al volumen de mensajes entrantes para las tres arquitecturas en Python:
proporcion = N_OUT / N_IN                     # respuestas por mensaje recibido en el mes del Día 33
entrantes = np.arange(500, 4_001, 5)
curvas = {}
for arq, color in [('Cloud API', '#3a9d5d'), ('Twilio', '#eb6834'), ('Wati', '#8a8986')]:
    curvas[arq] = np.array([sum(coste_mensajeria(arq, 'nuevo', n, n * proporcion, N_PLANT, T)) for n in entrantes])
umbral = FRANQUICIA / proporcion              # entrantes con los que las respuestas agotan la franquicia
cruce_twilio = entrantes[np.argmax(curvas['Twilio'] > RUBRO_WA)]
cruce_cloud = entrantes[np.argmax(curvas['Cloud API'] > RUBRO_WA)] if (curvas['Cloud API'] > RUBRO_WA).any() else None
print(f'La franquicia de 1 000 respuestas se agota con {umbral:.0f} mensajes entrantes al mes')
print(f'Twilio supera los 12 USD desde {cruce_twilio} entrantes | Cloud API: {cruce_cloud}')
for n in [1_000, 1_535, 3_000, 4_000]:
    i = int(np.where(entrantes == n)[0][0]) if n in entrantes else None
    if i is not None:
        print(f'{n:>5} entrantes: Cloud API {curvas["Cloud API"][i]:6.2f} | Twilio {curvas["Twilio"][i]:6.2f} '
              f'| Wati {curvas["Wati"][i]:6.2f} USD')

fig, ax = plt.subplots(figsize = (11, 5.2))
for arq, color in [('Cloud API', '#3a9d5d'), ('Twilio', '#eb6834'), ('Wati', '#8a8986')]:
    ax.plot(entrantes, curvas[arq], color = color, linewidth = 2.5, label = arq)
ax.axhline(RUBRO_WA, color = '#c8423b', linestyle = '--', linewidth = 1.5)
ax.text(3_980, RUBRO_WA + 0.8, 'Rubro: 12 USD', color = '#c8423b', ha = 'right', fontsize = 10)
ax.axvline(umbral, color = '#2a78d6', linestyle = ':', linewidth = 1.5)
ax.text(umbral + 40, 50, f'Se agota la franquicia\nde 1 000 respuestas\n({umbral:.0f} entrantes)', color = '#2a78d6', fontsize = 9)
ax.axvline(N_IN, color = '#52514e', linestyle = '--', linewidth = 1)
ax.text(N_IN + 40, 30, 'Mes del Día 33', color = '#52514e', fontsize = 9)
ax.set_ylim(0, 90)
ax.set_xlabel('Mensajes entrantes al mes')
ax.set_ylabel('USD al mes (régimen desde el 1 de octubre de 2026)')
ax.set_title('Coste de WhatsApp frente al volumen de mensajes', fontsize = 16)
ax.legend(loc = 'upper left', frameon = False)
ax.grid(color = '#e6e5e1')
ax.set_axisbelow(True)
plt.tight_layout()
plt.show()

La franquicia de 1 000 respuestas se agota con 1090 mensajes entrantes al mes
Twilio supera los 12 USD desde 795 entrantes | Cloud API: 2275
 1000 entrantes: Cloud API   2.78 | Twilio  14.01 | Wati  62.34 USD
 1535 entrantes: Cloud API   6.25 | Twilio  22.61 | Wati  66.50 USD
 3000 entrantes: Cloud API  17.67 | Twilio  48.07 | Wati  80.21 USD
 4000 entrantes: Cloud API  25.47 | Twilio  65.45 | Wati  89.57 USD

La gráfica tiene tres formas distintas y cada una cuenta algo:

• La Cloud API es plana hasta $1,090$ mensajes entrantes. Hasta ahí, las respuestas caben en la franquicia de $1,000$ y solo se pagan los recordatorios, $2.78$ USD. A partir de ese punto, cada respuesta adicional cuesta $0.0085$ USD y la recta empieza a subir con poca pendiente; el rubro de $12$ USD solo se rompe a partir de $2,275$ mensajes entrantes, un $48%$ más que hoy.
  
• Twilio sube desde el principio porque cobra cada mensaje recibido y enviado, haya franquicia o no, y en el cruce de la franquicia la pendiente aumenta todavía más. Supera el rubro desde $795$ mensajes entrantes: con el volumen actual de Trigo Lento, nunca cabe.
  
• Wati empieza en $62.34$ USD por la cuota fija y crece con la misma forma que la Cloud API, un poco más empinada por el recargo porcentual. Su problema no es la pendiente, es el punto de partida.

La pendiente de la Cloud API a partir de la franquicia sale de derivar la fórmula: con $n_{out} = \rho , n_{in}$ y $\rho = 1,408 / 1,535 = 0.917$, cada mensaje entrante adicional añade $\rho \cdot r_u = 0.0078$ USD, mientras que en Twilio añade $(1 + \rho) \cdot r_p + \rho \cdot r_u = 0.0174$ USD. El umbral donde la franquicia deja de cubrir es:

$$ n_{in}^{*} = \frac{F}{\rho} = \frac{1,000}{0.917} \approx 1,090 $$

La lógica:

• $F$ es la franquicia de mensajes de servicio por número y por mes.
  
• $\rho$ es la proporción de respuestas por mensaje recibido, que depende del estilo de atención: si el agente del módulo 4 respondiera dos veces por cada pregunta, $\rho$ subiría y el umbral bajaría.
  
• Por debajo de $n_{in}^{*}$, el régimen nuevo y el anterior cuestan lo mismo con la Cloud API; por encima, la diferencia crece $0.0078$ USD por cada mensaje entrante.

Sensibilidad a la tarifa de México

Las cifras anteriores usan la tarifa de utilidad de $0.0085$ USD, que es la mejor documentada, pero la Tabla 2 dejó claro que no es la única que circula. Un arquitecto no elige una puerta con un solo número cuando las fuentes no coinciden; mira cómo se mueve la decisión cuando el número se mueve. El siguiente bloque calcula el coste de la Cloud API en el régimen nuevo para siete tarifas de utilidad entre $0.0040$ y $0.0086$ USD (el rango completo de las fuentes) y siete volúmenes de recordatorios entre $200$ y $800$ al mes, y añade una pregunta que Valeria todavía no se ha hecho en voz alta: ¿qué pasaría si Trigo Lento mandara una promoción al mes?

# Sensibilidad del coste de la Cloud API a la tarifa de utilidad y a los recordatorios en Python:
tarifas_u = np.round(np.linspace(0.0040, 0.0086, 7), 4)
recordatorios = np.arange(200, 801, 100)
malla = np.zeros((len(recordatorios), len(tarifas_u)))
for i, n_plant in enumerate(recordatorios):
    for j, r_u in enumerate(tarifas_u):
        t = dict(T, meta_utilidad_mx = r_u, meta_servicio_mx = r_u)
        malla[i, j] = sum(coste_mensajeria('Cloud API', 'nuevo', N_IN, N_OUT, n_plant, t))
print(f'Cloud API desde el 1-oct: mínimo {malla.min():.2f} USD | máximo {malla.max():.2f} USD | '
      f'celdas por encima de 12: {(malla > RUBRO_WA).sum()} de {malla.size}')
for r_u in [0.0040, 0.0085, 0.0086]:
    t = dict(T, meta_utilidad_mx = r_u, meta_servicio_mx = r_u)
    print(f'r_u = {r_u:.4f}: mes base {sum(coste_mensajeria("Cloud API", "nuevo", N_IN, N_OUT, N_PLANT, t)):.2f} USD '
          f'| volumen de diseño {sum(coste_mensajeria("Cloud API", "nuevo", 1_560, 1_560, 468, t)):.2f} USD')

# Una campaña de marketing al mes a 300 clientes con consentimiento de marketing:
for nombre, r_m in [('Tabla C', 0.0305), ('otra fuente', 0.0378), ('1-oct-2026', 0.0397)]:
    base = sum(coste_mensajeria('Cloud API', 'nuevo', N_IN, N_OUT, N_PLANT, T))
    print(f'Marketing a {nombre} ({r_m}): 300 mensajes = {300 * r_m:.2f} USD | total {base + 300 * r_m:.2f} USD')

fig, ax = plt.subplots(figsize = (10, 5.6))
im = ax.imshow(malla, cmap = 'YlGn_r', origin = 'lower', aspect = 'auto', vmin = 0, vmax = RUBRO_WA)
ax.set_xticks(range(len(tarifas_u)), [f'{v:.4f}' for v in tarifas_u])
ax.set_yticks(range(len(recordatorios)), recordatorios)
for i in range(len(recordatorios)):
    for j in range(len(tarifas_u)):
        ax.text(j, i, f'{malla[i, j]:.2f}', ha = 'center', va = 'center', fontsize = 9,
                color = 'white' if malla[i, j] < 6 else '#1f1f1f')
ax.set_xlabel('Tarifa de utilidad y de servicio de Meta en México (USD por mensaje)')
ax.set_ylabel('Recordatorios al mes')
ax.set_title('Cloud API directa desde el 1 de octubre: USD al mes', fontsize = 16)
fig.colorbar(im, ax = ax, label = 'USD al mes (escala hasta el rubro de 12)')
plt.tight_layout()
plt.show()

Cloud API desde el 1-oct: mínimo 2.43 USD | máximo 10.39 USD | celdas por encima de 12: 0 de 49
r_u = 0.0040: mes base 2.94 USD | volumen de diseño 4.11 USD
r_u = 0.0085: mes base 6.25 USD | volumen de diseño 8.74 USD
r_u = 0.0086: mes base 6.33 USD | volumen de diseño 8.84 USD
Marketing a Tabla C (0.0305): 300 mensajes = 9.15 USD | total 15.40 USD
Marketing a otra fuente (0.0378): 300 mensajes = 11.34 USD | total 17.59 USD
Marketing a 1-oct-2026 (0.0397): 300 mensajes = 11.91 USD | total 18.16 USD

El mapa de calor es verde de punta a punta: el coste va de $2.43$ USD (tarifa más baja y $200$ recordatorios) a $10.39$ USD (tarifa más alta y $800$ recordatorios), y ninguna de las $49$ celdas supera los $12$ USD. Con el volumen de diseño, la tarifa más baja da $4.11$ USD y la más alta $8.84$. La conclusión del Bloque 4 es robusta: ninguna tarifa de utilidad publicada cambia la decisión.

La segunda parte de la salida es la que sí la cambiaría. Una sola campaña mensual de marketing a $300$ clientes con consentimiento de marketing cuesta entre $9.15$ y $11.91$ USD según la tarifa que se crea, y lleva el rubro de WhatsApp a $15.40$ USD en el mejor caso y a $18.16$ USD con la tarifa del 1 de octubre de 2026. Es decir: la puerta barata deja de caber en el presupuesto en cuanto se usa para promociones. La categoría de la plantilla pesa más que la tarifa dentro de la categoría, y la incertidumbre que importa no es la de la utilidad ($0.0040$ a $0.0086$), sino la de marketing, que además sube en México el mismo día que cambia el cobro del servicio.

De ahí la regla que Valeria anota en su cuaderno: las promociones de Trigo Lento no salen por WhatsApp mientras el rubro sea de 12 USD. Si algún día se hacen, saldrán con consentimiento de marketing, con un rubro propio y por un canal cuyo coste esté medido, como el correo o Instagram, que el Día 72 tratará con su publicación multired.

La decisión de Valeria

Los números favorecen a la Cloud API, pero Don Ernesto tiene una pregunta que no es de dinero: “Si lo barato es hacerlo todo nosotros, ¿quién contesta cuando el servidor se cae un sábado?” Es la columna de operación de la Tabla 3, y no se puede ignorar. Para ponerla en la misma balanza que el coste, Valeria usa una matriz de decisión ponderada, la herramienta que el Día 13 aplicó para elegir plataformas:

$$ S_a = \sum_{k} w_k \cdot s_{a,k}, \qquad \sum_k w_k = 1 $$

La lógica:

• $s_{a,k}$ es la nota de la arquitectura $a$ en el criterio $k$, de $1$ (peor) a $5$ (mejor). Las notas de coste salen de la Tabla 4; las de operación, dependencia y funciones, de la Tabla 3.
  
• $w_k$ es el peso de cada criterio, que refleja lo que le importa a Trigo Lento: coste $0.35$ (el presupuesto es la restricción más dura), operación $0.25$ (Valeria es una sola persona), dependencia $0.20$ y funciones $0.20$.
  
• $S_a$ es la puntuación final; gana la más alta. Como los pesos son una opinión, el bloque también mide si la decisión sobrevive a otros pesos parecidos.

# Matriz de decisión ponderada y su robustez ante pesos aleatorios en Python:
pesos = pd.Series({'coste': 0.35, 'operacion': 0.25, 'dependencia': 0.20, 'funciones': 0.20})
notas = pd.DataFrame({
    'Cloud API': {'coste': 5, 'operacion': 2, 'dependencia': 4, 'funciones': 3},
    'Twilio':    {'coste': 2, 'operacion': 4, 'dependencia': 3, 'funciones': 4},
    'Wati':      {'coste': 1, 'operacion': 5, 'dependencia': 2, 'funciones': 5},
}).T[pesos.index]
puntuacion = (notas * pesos).sum(axis = 1).round(2)
print(notas.assign(puntuacion = puntuacion).sort_values('puntuacion', ascending = False).to_string())

# 10 000 juegos de pesos al azar alrededor de los elegidos (Dirichlet), para ver si la decisión es frágil:
simulados = rng.dirichlet(pesos.values * 20, size = 10_000)
ganador = pd.Series(np.array(notas.index)[(simulados @ notas.values.T).argmax(axis = 1)]).value_counts(normalize = True)
print('Gana con pesos al azar:', {k: f'{v:.1%}' for k, v in ganador.items()})
peso_coste_empate = None
for w in np.arange(0.0, 0.501, 0.01):
    resto = pesos.drop('coste') / pesos.drop('coste').sum() * (1 - w)
    p = pd.concat([pd.Series({'coste': w}), resto])[pesos.index]
    s = (notas * p).sum(axis = 1)
    if s['Cloud API'] >= s.drop('Cloud API').max():
        peso_coste_empate = round(w, 2)
        break
print('Peso mínimo del coste para que gane la Cloud API:', peso_coste_empate)

           coste  operacion  dependencia  funciones  puntuacion
Cloud API      5          2            4          3        3.65
Twilio         2          4            3          4        3.10
Wati           1          5            2          5        3.00
Gana con pesos al azar: {'Cloud API': '84.1%', 'Wati': '15.8%', 'Twilio': '0.1%'}
Peso mínimo del coste para que gane la Cloud API: 0.23

La Tabla 5 recoge las notas y las puntuaciones.

Tabla 5. Matriz de decisión ponderada para la puerta de WhatsApp de Trigo Lento (notas de 1 a 5).

La Cloud API gana con $3.65$ puntos, seguida de Twilio con $3.10$ y Wati con $3.00$. Más interesante que la cifra es su robustez: con $10,000$ juegos de pesos tomados al azar alrededor de los elegidos (una distribución de Dirichlet centrada en ellos), la Cloud API gana el $84.1%$ de las veces, Wati el $15.8%$ y Twilio casi nunca. Y basta con que el coste pese $0.23$ o más para que la Cloud API quede primera; por debajo de ese peso, cuando lo que más importa es no operar nada, gana Wati. Twilio, la puerta actual, nunca es la mejor opción: no es la más barata ni la más cómoda, sino la que estaba a mano cuando el Día 23 hizo falta recibir el primer mensaje.

La decisión, entonces, es la Cloud API directa desde n8n, con Twilio documentado como plan de respaldo: la cuenta de Twilio no se cierra, el webhook de TL Pedidos WhatsApp v3 del Día 33 sigue exportado en el repositorio y el manual de reversión dice cómo volver a él en una tarde si la verificación del negocio se retrasa o el servidor falla de forma repetida. El esfuerzo de operación, la nota más baja de la Cloud API, es justo lo que el módulo 4 preparó: un n8n propio con respaldos, versionado y pruebas.

El último paso de la decisión es el dinero. El siguiente bloque rehace el reparto de los $45$ USD con la Cloud API: los rubros se quedan como en la Tabla E del Día 12, pero el gasto previsto cambia, y el bloque comprueba con aserciones que tanto los rubros como el gasto previsto más la reserva suman exactamente $45.00$:

# Presupuesto revisado con la Cloud API directa y comprobación de que suma 45.00 en Python:
tabla_e = pd.Series({'Make Core': 10.59, 'Servidor n8n': 6.00, 'API de Claude': 8.00,
                     'WhatsApp': 12.00, 'Reserva': 8.41})
previsto_wa = round(sum(coste_mensajeria('Cloud API', 'nuevo', N_IN, N_OUT, N_PLANT, T)), 2)
tabla4 = pd.DataFrame({'tabla_e': tabla_e, 'rubro_nuevo': tabla_e})
tabla4['previsto'] = [10.59, 6.00, 8.00, previsto_wa, np.nan]   # Claude: el tope de la consola
tabla4.loc['Reserva', 'previsto'] = round(PRESUPUESTO - tabla4.previsto.drop('Reserva').sum(), 2)
assert round(tabla4.rubro_nuevo.sum(), 2) == PRESUPUESTO, 'Los rubros no suman 45.00'
assert round(tabla4.previsto.sum(), 2) == PRESUPUESTO
print(tabla4.to_string())
print(f'Rubros: {tabla4.rubro_nuevo.sum():.2f} USD | gasto previsto sin reserva: '
      f'{tabla4.previsto.drop("Reserva").sum():.2f} USD | holgura real: {tabla4.previsto["Reserva"]:.2f} USD')
print(f'WhatsApp previsto: {previsto_wa:.2f} USD = {previsto_wa * MXN_POR_USD:.2f} MXN '
      f'({previsto_wa / RUBRO_WA:.0%} de su rubro)')

fig, ax = plt.subplots(figsize = (11, 4.6))
colores = {'Make Core': '#2a78d6', 'Servidor n8n': '#7a5cc9', 'API de Claude': '#e0a526',
           'WhatsApp': '#3a9d5d', 'Reserva': '#c9c8c3'}
filas_graf = {'Tabla E (plan)': tabla_e,
              'Día 33 (Twilio)': pd.Series({'Make Core': 18.53, 'Servidor n8n': 6.00, 'API de Claude': 0.74,
                                            'WhatsApp': 19.13, 'Reserva': 0.59}),
              'Previsto (Cloud API)': tabla4.previsto}
for k, (nombre, serie) in enumerate(filas_graf.items()):
    izquierda = 0
    for rubro, color in colores.items():
        v = serie[rubro]
        ax.barh(k, v, left = izquierda, color = color, label = rubro if k == 0 else None, edgecolor = 'white')
        if v >= 2.5:
            ax.text(izquierda + v / 2, k, f'{v:.2f}', ha = 'center', va = 'center', fontsize = 9,
                    color = 'white' if rubro != 'Reserva' else '#1f1f1f')
        izquierda += v
ax.axvline(PRESUPUESTO, color = '#c8423b', linestyle = '--', linewidth = 1.5)
ax.set_yticks(range(3), list(filas_graf))
ax.invert_yaxis()
ax.set_xlabel('USD al mes')
ax.set_title('Reparto de los 45 USD: plan, Día 33 y previsto con la Cloud API', fontsize = 16)
ax.legend(loc = 'upper center', bbox_to_anchor = (0.5, -0.18), ncol = 5, frameon = False)
plt.tight_layout()
plt.show()

               tabla_e  rubro_nuevo  previsto
Make Core        10.59        10.59     10.59
Servidor n8n      6.00         6.00      6.00
API de Claude     8.00         8.00      8.00
WhatsApp         12.00        12.00      6.25
Reserva           8.41         8.41     14.16
Rubros: 45.00 USD | gasto previsto sin reserva: 30.84 USD | holgura real: 14.16 USD
WhatsApp previsto: 6.25 USD = 115.62 MXN (52% de su rubro)

La Tabla 6 es el presupuesto revisado.

Tabla 6. Presupuesto revisado de Trigo Lento con WhatsApp por la Cloud API directa (USD al mes).

Tres decisiones sostienen la tabla. Make vuelve a $10.59$ USD porque el flujo de mensajes que consumía los bloques extra de créditos se mudó a n8n en el Día 45. La API de Claude se presupuesta con su tope completo de $8$ USD, no con los $0.74$ del Día 33, porque el agente de pedidos del módulo 4 y el módulo 6 la usarán mucho más que la cascada de Make. Y WhatsApp conserva su rubro de $12$ USD con $6.25$ previstos, el $52%$ del rubro ($115.62$ MXN al tipo didáctico), de modo que el margen de $5.75$ USD absorbe un crecimiento del volumen o una subida de tarifa sin tocar los demás rubros. La reserva real, $14.16$ USD, vuelve a existir por primera vez desde el Día 21.

Lo que dijo Don Ernesto

Don Ernesto escucha la decisión con los brazos cruzados y hace la pregunta que mejor resume el día: "¿Y si Meta vuelve a cambiar las reglas?" No es una objeción retórica. En quince meses, Meta pasó de cobrar por conversación a cobrar por mensaje (julio de 2025), regaló las plantillas de utilidad dentro de la ventana y las volvió a cobrar (octubre de 2026), y subió la tarifa de marketing de México el mismo día. Nada impide un tercer cambio. La respuesta de Valeria tiene tres partes, y ninguna es “confíe en mí”:

1. Revisión trimestral de precios. Meta publica sus tarjetas de tarifas con fecha de vigencia y avisa con antelación de los cambios; Valeria añade al calendario del negocio una revisión el primer lunes de enero, abril, julio y octubre, en la que actualiza la Tabla 2 con su fuente y su fecha, y vuelve a correr los bloques 4 y 7.
   
2. Tope de gasto por rubro. La consola de Claude ya tiene un tope de $8$ USD desde el módulo 2; WhatsApp tendrá su equivalente en n8n: si el gasto acumulado del mes pasa de $10$ USD, el flujo deja de enviar recordatorios automáticos y avisa a Valeria, que decide a mano. Las respuestas a clientes que escribieron primero nunca se cortan.
   
3. Medir cada mensaje, no la factura. La Cloud API informa el precio de cada mensaje en los webhooks de estado. Si el gasto se lee mensaje a mensaje, un cambio de reglas aparece en el registro el mismo día, no en la factura del mes siguiente.

La tercera parte es la que se puede construir hoy. Cuando la Cloud API entrega un mensaje, envía al webhook del negocio un estado (sent, delivered, read o failed) con un objeto pricing que dice si ese mensaje se cobra y con qué tarifa: type vale regular cuando es facturable, free_customer_service cuando es gratuito por ir dentro de la ventana y free_entry_point cuando cae en una ventana gratuita de puntos de entrada; category dice la tarifa (service, utility, marketing, authentication) y pricing_model vale PMP, por mensaje. La documentación avisa que el campo billable se retirará en una versión futura y pide usar type y category juntos.

El siguiente cuerpo es un ejemplo con datos inventados de lo que recibe el webhook de n8n: un cambio con un mensaje entrante de una clienta y otro cambio con tres estados. El primer estado es una respuesta que todavía cae en la franquicia del mes, el segundo una respuesta que ya la superó y el tercero un recordatorio de recogida con plantilla de utilidad. La estructura (entry[].changes[].value.messages[] y statuses[] con su pricing) es la de la referencia de webhooks de Meta; que una respuesta dentro de la franquicia llegue marcada como free_customer_service es un supuesto de la entrada que debe contrastarse con un webhook real antes de confiar en el contador:

{
  "object": "whatsapp_business_account",
  "entry": [
    {
      "id": "WABA-EJEMPLO-NO-REAL-0046",
      "changes": [
        {
          "field": "messages",
          "value": {
            "messaging_product": "whatsapp",
            "metadata": {
              "display_phone_number": "525500000099",
              "phone_number_id": "PNID-EJEMPLO-NO-REAL-0046"
            },
            "contacts": [
              {
                "profile": {
                  "name": "Clienta de prueba"
                },
                "wa_id": "525500000017"
              }
            ],
            "messages": [
              {
                "from": "525500000017",
                "id": "wamid.EJEMPLO-NO-REAL-0100",
                "timestamp": "1773866940",
                "type": "text",
                "text": {
                  "body": "Hola, ¿me aparta dos hogazas para el sábado?"
                }
              }
            ]
          }
        },
        {
          "field": "messages",
          "value": {
            "messaging_product": "whatsapp",
            "metadata": {
              "display_phone_number": "525500000099",
              "phone_number_id": "PNID-EJEMPLO-NO-REAL-0046"
            },
            "statuses": [
              {
                "id": "wamid.EJEMPLO-NO-REAL-0001",
                "status": "delivered",
                "timestamp": "1773867000",
                "recipient_id": "525500000017",
                "pricing": {
                  "billable": false,
                  "pricing_model": "PMP",
                  "type": "free_customer_service",
                  "category": "service"
                }
              },
              {
                "id": "wamid.EJEMPLO-NO-REAL-0002",
                "status": "delivered",
                "timestamp": "1773867060",
                "recipient_id": "525500000017",
                "pricing": {
                  "billable": true,
                  "pricing_model": "PMP",
                  "type": "regular",
                  "category": "service"
                }
              },
              {
                "id": "wamid.EJEMPLO-NO-REAL-0003",
                "status": "delivered",
                "timestamp": "1773867120",
                "recipient_id": "525500000017",
                "pricing": {
                  "billable": true,
                  "pricing_model": "PMP",
                  "type": "regular",
                  "category": "utility"
                }
              }
            ]
          }
        }
      ]
    }
  ]
}

Tres detalles del cuerpo importan para el contador. Los identificadores (wamid, el de la cuenta y el del número) son de ejemplo y llevan EJEMPLO-NO-REAL, y el teléfono es del rango de prueba de la serie. El mensaje entrante y los estados llegan en cambios distintos, a veces en peticiones distintas, de modo que el contador no puede suponer que un mensaje y su estado viajan juntos. Y no hay importe en el cuerpo: Meta dice qué tarifa aplica, no cuánto cuesta, y el importe sale de multiplicar por la tarjeta vigente.

El siguiente bloque es el taxímetro de Trigo Lento: lee los estados del cuerpo, descarta los repetidos por su identificador (el webhook reintenta y un mismo estado puede llegar dos veces), suma el precio de los facturables y, en una segunda parte, simula un mes de respuestas para ver en qué día hábil se agota la franquicia:

# Taxímetro de mensajes: leer el precio de cada estado del webhook y acumular el coste del mes en Python:
with open(carpeta / 'webhook_estados_ejemplo.json', encoding = 'utf-8') as f:
    cuerpo = json.load(f)
estados = [s for e in cuerpo['entry'] for c in e['changes'] for s in c['value'].get('statuses', [])]
entrantes_wh = [m for e in cuerpo['entry'] for c in e['changes'] for m in c['value'].get('messages', [])]
TARIFA_CATEGORIA = {'service': T['meta_servicio_mx'], 'utility': T['meta_utilidad_mx'],
                    'marketing': T['meta_marketing_mx'], 'authentication': T['meta_autenticacion_mx']}

def coste_estado(estado):
    # Se cobra lo que Meta marca como regular; billable está en vías de retirarse y no se usa:
    p = estado.get('pricing')
    if not p or p['type'] != 'regular':
        return 0.0
    return TARIFA_CATEGORIA[p['category']]

vistos, acumulado = set(), 0.0
for s in estados + estados[:1]:              # el primer estado llega dos veces: el webhook reintenta
    if s['id'] in vistos:
        continue
    vistos.add(s['id'])
    acumulado += coste_estado(s)
    print(f"{s['id']:<28} {s['pricing']['type']:<22} {s['pricing']['category']:<8} {coste_estado(s):.4f} USD")
print(f'Entrantes en el cuerpo: {len(entrantes_wh)} | estados únicos: {len(vistos)} | coste: {acumulado:.4f} USD')

# Un mes simulado: las respuestas pasan a ser regular a partir de la número 1 001:
dias = 26
resp_dia = rng.poisson(N_OUT / dias, dias)
plant_dia = rng.poisson(N_PLANT / dias, dias)
acumulado_respuestas = np.cumsum(resp_dia)
cobradas = np.maximum(0, acumulado_respuestas - FRANQUICIA)
coste_dia = np.diff(np.concatenate([[0], cobradas])) * T['meta_servicio_mx'] + plant_dia * T['meta_utilidad_mx']
dia_cruce = int(np.argmax(acumulado_respuestas > FRANQUICIA)) + 1
print(f'Respuestas del mes: {resp_dia.sum()} | recordatorios: {plant_dia.sum()} | '
      f'la franquicia se agota el día hábil {dia_cruce} | coste del mes: {coste_dia.sum():.2f} USD')

wamid.EJEMPLO-NO-REAL-0001   free_customer_service  service  0.0000 USD
wamid.EJEMPLO-NO-REAL-0002   regular                service  0.0085 USD
wamid.EJEMPLO-NO-REAL-0003   regular                utility  0.0085 USD
Entrantes en el cuerpo: 1 | estados únicos: 3 | coste: 0.0170 USD
Respuestas del mes: 1350 | recordatorios: 364 | la franquicia se agota el día hábil 20 | coste del mes: 6.07 USD

El cuerpo de ejemplo cuesta $0.0170$ USD: la primera respuesta es gratuita, la segunda y el recordatorio se cobran a $0.0085$ cada uno. El primer estado llegó dos veces y se contó una, que es la lección del Día 29 aplicada al dinero: sin la clave de idempotencia, cada reintento del webhook inflaría el gasto registrado. En el mes simulado, con $1,350$ respuestas y $364$ recordatorios, la franquicia se agota el día hábil $20$ y el mes cuesta $6.07$ USD, muy cerca de los $6.25$ del cálculo analítico; la diferencia es el azar de los volúmenes diarios.

El contador tiene dos usos que valen más que su precisión. El primero es la alarma temprana: si un día de marzo el contador marca más respuestas cobradas que las previstas, o una categoría inesperada (un marketing donde solo debería haber utility), Valeria lo sabe esa tarde. El segundo es la conciliación: a fin de mes, la suma del contador se compara con la factura de Meta, y una diferencia de más de unos centavos significa que una tarifa cambió o que algo se cuenta mal. En los dos casos, la respuesta a “¿y si Meta cambia las reglas?” deja de ser una promesa y se convierte en un registro.

Don Ernesto mira el contador un buen rato y pone una última condición: “Que el aparato aquel me diga cada lunes cuánto llevamos. En pesos.” El Día 53 convertirá esa petición en indicadores de servicio y el módulo 6 en un informe del lunes; por ahora, $6.25$ USD son $115.62$ MXN al tipo didáctico, y Don Ernesto se va al obrador con la cifra apuntada en el delantal.

Consideraciones finales

El día empezó con una cifra subrayada en rojo y termina con una factura desarmada. Los $19.13$ USD del Día 33 no eran el precio de WhatsApp, sino el precio de entrar a WhatsApp por una puerta que cobra cada mensaje, incluidos los que envía el cliente. La misma mensajería cuesta $2.78$ USD con la Cloud API directa en el régimen anterior y $6.25$ en el nuevo, y cabe en su rubro con el volumen de hoy, con el volumen de diseño y con cualquier tarifa de utilidad publicada. Lo que no cabe es una promoción mensual, y esa es una decisión de negocio, no de arquitectura.

Las cifras de hoy tienen límites que conviene decir. Las tarifas de México proceden de la tarjeta de Meta citada por fuentes secundarias, porque la tarjeta se descarga como archivo y la página no muestra el importe; el recargo de Wati tiene dos lecturas que no coinciden; los volúmenes son los de un mes simulado, no los de una factura; la proporción de respuestas por mensaje depende de cómo atienda el agente; y la marca free_customer_service de las respuestas dentro de la franquicia es un supuesto a contrastar. Ninguno de esos límites cambia la decisión, como mostraron la sensibilidad y la matriz ponderada, pero todos justifican la revisión trimestral.

Antes de elegir la puerta de WhatsApp de cualquier negocio, conviene hacerse algunas preguntas:

• ¿Separó lo que cobra Meta de lo que cobra el proveedor, y sabe cuál de las dos partes crece con el volumen?
  
• ¿Cuenta los mensajes que recibe, y no solo los que envía, cuando el proveedor cobra por ambos?
  
• ¿Sabe con cuántos mensajes al mes se agota la franquicia de servicio y qué pasa con su coste a partir de ahí?
  
• ¿Qué categoría de plantilla usa cada mensaje, y tiene el consentimiento que esa categoría exige?
  
• ¿Quién opera el webhook un sábado por la tarde, y cuál es el plan de respaldo si falla?

Un gran libro que habla de esto es Pricing and Revenue Optimization (o Fijación de precios y optimización de ingresos), de Robert L. Phillips, en el que se explica cómo las empresas diseñan tarifas por segmento, por volumen y por canal, y por qué las cambian. Leerlo desde el otro lado del mostrador, el del cliente que paga, ayuda a entender por qué una plataforma regala la franquicia de servicio, cobra más el marketing y premia el volumen con escalones: cada regla de la tarjeta de Meta es una decisión de precios con una intención, y anticipar la siguiente es parte del trabajo del arquitecto.

En mensajería, el canal no es lo caro: lo caro es quién cobra cada mensaje entre el negocio y el cliente. Con la Cloud API directa, Trigo Lento paga solo lo que Meta cobra, conoce el precio de cada mensaje el día que lo envía y vuelve a tener una reserva en su presupuesto.

Conclusiones clave

Modelo de cobro

• WhatsApp Business Platform cobra por mensaje entregado, según la categoría de la plantilla (marketing, utilidad, autenticación) y el país del destinatario; los mensajes que envía el cliente nunca los cobra Meta.
  
• Desde el 1 de octubre de 2026, Meta cobra los mensajes de servicio a la tarifa de utilidad a partir del número $1,001$ de cada mes y por número, y cobra las plantillas de utilidad dentro de la ventana; en México la utilidad cuesta $0.0085$ USD.
  
• La categoría pesa más que la tarifa: una promoción mensual a $300$ clientes cuesta entre $9.15$ y $11.91$ USD y rompería el rubro de WhatsApp.

Proveedores

• Los $19.13$ USD del Día 33 son en un $85.4%$ recargo de Twilio: $0.005$ USD por cada mensaje recibido o enviado, $16.35$ USD al mes que no dependen del régimen de Meta.
  
• La Cloud API directa cuesta $2.78$ USD antes del cambio y $6.25$ después, Twilio $19.14$ y $22.61$, y Wati Growth al menos $62.34$ por su cuota fija.
  
• La matriz ponderada elige la Cloud API con $3.65$ puntos y gana en el $84.1%$ de $10,000$ juegos de pesos al azar; Twilio queda documentado como plan de respaldo.

Presupuesto

• Con la Cloud API, WhatsApp usa el $52%$ de su rubro de $12$ USD y no lo rompe con ninguna tarifa de utilidad publicada ni con el volumen de diseño ($8.74$ USD).
  
• El presupuesto revisado suma $45.00$ USD con $30.84$ de gasto previsto y $14.16$ de reserva, la primera reserva real desde el Día 21.
  
• El gasto se vigila mensaje a mensaje con el objeto pricing de los webhooks de estado, con revisión trimestral de tarifas y un tope de $10$ USD que detiene los recordatorios, nunca las respuestas.

Mañana, en el Día 47: Gmail con criterio: OAuth, etiquetas y borradores contextuales con Claude. Marisol escribe los lunes a las 7:40 para cambiar cantidades, pedir su factura y, a veces, quejarse de una entrega; mañana Valeria conectará el buzón de mayoristas con el mínimo permiso necesario, clasificará los correos con Claude y dejará borradores que solo salen con su firma.

Referencias

1. Meta (2026). Pricing on the WhatsApp Business Platform. https://developers.facebook.com/documentation/business-messaging/whatsapp/pricing (revisado en octubre de 2026).
   
2. Meta (2026). Status messages webhook reference. https://developers.facebook.com/documentation/business-messaging/whatsapp/webhooks/reference/messages/status (revisado en octubre de 2026).
   
3. Twilio (2026). WhatsApp pricing. https://www.twilio.com/en-us/whatsapp/pricing (revisado en octubre de 2026).
   
4. Twilio (2026). Notice: Changes to WhatsApp’s Pricing, October 2026. Centro de soporte de Twilio. https://support.twilio.com/hc/en-us/articles/53100462475931-Notice-Changes-to-WhatsApp-s-Pricing-October-2026
   
5. Twilio (2026). SMS pricing: Mexico. https://www.twilio.com/en-us/sms/pricing/mx (revisado en octubre de 2026).
   
6. Wati (2026). Pricing. https://www.wati.io/pricing (cifras contrastadas con fuentes secundarias que no coinciden; revisado en octubre de 2026).
   
7. Meta (2026). WhatsApp Business Messaging Policy. https://business.whatsapp.com/policy
   
8. Phillips, R. L. (2021). Pricing and Revenue Optimization (2.ª ed.). Stanford University Press.