¿Cuántos números de WhatsApp necesita tu agente de IA?

En whasp, la cantidad de números de WhatsApp que necesita tu agente de IA es la mayor de tres divisiones, cada una redondeada hacia arriba: usuarios activos entre 80, registros de tu día más ocupado entre 32 y mensajes enviados en tu día más ocupado entre 1.200. Esos valores son el 80% de los límites por número. Añade uno o dos números de reserva por si hay baneos.

¿Qué límites tiene un número?

Un número de whasp es una cuenta personal real de WhatsApp en su propio teléfono en la nube y con su propia IP, así que sus límites se aplican por número. La referencia de la API los lista:

Un número se marca at_risk cuando cualquier límite supera el 80%, así que los techos de planificación son 80 usuarios, 32 chats nuevos y 1.200 envíos. Dos datos más condicionan un plan. Los mensajes de un número salen uno a uno, con un segundo de diferencia aproximadamente, así que una cola de 120 respuestas tarda unos dos minutos en vaciarse. Y la cuenta admite 100 solicitudes a la API cada 10 segundos, es decir, 10 por segundo, el mismo ritmo que 10 números enviando a tope. Más allá de eso, haz cola de tu lado.

Cuenta los usuarios activos como lo hace whasp: las personas que escribieron en los últimos 30 días móviles, no el total de registros. Quienes se quedan en silencio salen de la cuenta pasados 30 días. GET /v1/numbers/{number}/chats lista quién escribió y cuándo, así que puedes medirlo.

¿Cómo calculas los números que necesitas?

El cálculo toma tres datos de tus propios registros: los usuarios activos (U), los usuarios nuevos de tu día más ocupado (S) y los mensajes que envías en tu día más ocupado (M). Cada límite da una cifra, y gana la mayor:

• por usuarios: U / (100 x 0,8) = U / 80
• por registros: S / (40 x 0,8) = S / 32
• por envíos: M / (1.500 x 0,8) = M / 1.200

Después suma una reserva del 10%, de al menos uno. Cuando un número pasa a critical (baneado, con la sesión cerrada, con el teléfono sin conexión más de 10 minutos o con envíos fallidos), /numbers/pick deja de ofrecerlo y su parte de los registros nuevos recae en los demás. El reemplazo llega sin costo pero vacío, y tu propia lógica migra a los usuarios al número nuevo. La reserva es donde caben mientras eso ocurre. Cada número cuesta $49 cada 30 días.

// Límites por número de la referencia de la API de whasp, y la carga para la que planificamos.
const LIMITS = { users: 100, signups: 40, sends: 1500 };
const PLAN = 0.8; // por encima del 80% de un límite, un número se marca at_risk

export function numbersNeeded(users: number, busiestDaySignups: number, busiestDaySends: number) {
  const byUsers = Math.ceil(users / (LIMITS.users * PLAN));
  const bySignups = Math.ceil(busiestDaySignups / (LIMITS.signups * PLAN));
  const bySends = Math.ceil(busiestDaySends / (LIMITS.sends * PLAN));
  const base = Math.max(byUsers, bySignups, bySends);
  const spare = Math.max(1, Math.ceil(base * 0.1)); // espacio para un número que pase a critical
  return { byUsers, bySignups, bySends, base, spare, total: base + spare, monthlyUsd: (base + spare) * 49 };
}

¿Cómo son tres planes de tamaño real?

Los tres planes de abajo usan supuestos de ejemplo, no mediciones. Sustitúyelos por números de tus propios registros.

Un tutor de idiomas con 3.000 usuarios activos

Supón que el 25% de los usuarios activos escribe en un día cualquiera, que el agente envía a cada uno 12 mensajes, que el día más ocupado es el doble del promedio y que un lanzamiento trae 400 usuarios nuevos en un día.

• Envíos: 3.000 x 0,25 x 12 = 9.000 en un día promedio, 18.000 en el más ocupado.
• Por usuarios: 3.000 / 80 = 37,5, así que 38. Por registros: 400 / 32 = 12,5, así que 13. Por envíos: 18.000 / 1.200 = 15.
• La mayor es 38. Reserva: 10% de 38 = 3,8, así que 4. Total 42 números, 42 x $49 = $2.058 al mes, o $0,69 por usuario activo.

Aquí deciden los usuarios.

Un compañero muy conversador con 1.200 usuarios activos

Supón que el 50% escribe en un día cualquiera, que el agente envía a cada uno 40 mensajes, que el día más ocupado es 1,5 veces el promedio y que ese día llegan 100 usuarios nuevos.

• Envíos: 1.200 x 0,5 x 40 = 24.000 en un día promedio, 36.000 en el más ocupado.
• Por usuarios: 1.200 / 80 = 15. Por registros: 100 / 32 = 3,1, así que 4. Por envíos: 36.000 / 1.200 = 30.
• La mayor es 30. Reserva 3. Total 33 números, 33 x $49 = $1.617, o $1,35 por usuario activo.

Aquí deciden los mensajes. Con 80 usuarios por número, 1.200 envíos al día permiten 15 mensajes por usuario activo al día. Este compañero envía 30 por usuario activo en su día más ocupado, así que necesita el doble de números de lo que sugiere su cantidad de usuarios.

Un lanzamiento con 1.000 registros en un día

Supón 1.000 usuarios en total y 6.000 mensajes enviados ese día.

• Por usuarios: 1.000 / 80 = 12,5, así que 13. Por registros: 1.000 / 32 = 31,25, así que 32. Por envíos: 6.000 / 1.200 = 5.
• La mayor es 32. Reserva 4. Total 36 números, $1.764 al mes.

Ahora reparte los mismos 1.000 registros en cinco días, 200 al día, con 1.200 envíos en el día más ocupado:

• Por usuarios: 13. Por registros: 200 / 32 = 6,25, así que 7. Por envíos: 1.200 / 1.200 = 1.
• La mayor es 13. Reserva 2. Total 15 números, $735 al mes.

Una lista de espera o unos códigos de invitación ahorrarían 21 números y $1.029 al mes. En este ejemplo el límite que manda son los chats nuevos por día, no los usuarios.

¿Cómo enrutas a los usuarios nuevos y los mantienes en un número?

GET /v1/numbers/pick devuelve el número sano y en línea con más espacio para un usuario nuevo, y un enlace wa.me que abre el chat. Pasa text y el enlace se abre con ese mensaje prefijado. Pon en él el id de tu usuario, para que el agente sepa quién escribe (Enlace wa.me con mensaje prellenado y código QR para tu agente).

const API = "https://api.whasp.ai/v1";
const headers = { Authorization: `Bearer ${process.env.WHASP_API_KEY}` };

/** El enlace que se muestra a un usuario nuevo, o null cuando todos los números están llenos. */
export async function signupLink(userId: string): Promise<string | null> {
  const params = new URLSearchParams({ text: `Hola, mi código es ${userId}` });
  const res = await fetch(`${API}/numbers/pick?${params}`, { headers });
  if (res.status === 409) return null; // no_capacity: retén el registro y añade un número
  if (!res.ok) throw new Error(`pick failed with ${res.status}`);
  const { wa_link } = (await res.json()) as { number: string; wa_link: string };
  return wa_link;
}

Un chat se queda en su número. Cuando envías sin from, whasp usa el número al que la persona escribió por última vez, que es lo que quieres. Un from distinto devuelve 409 chat_not_open, salvo que esa persona también haya escrito a ese número.

Cuando signupLink devuelve null, muestra una pantalla de espera y añade números. Añádelos antes de necesitarlos: POST /v1/numbers puede responder 503 no_capacity cuando ninguno está listo (no se cobra nada), y un número que se configura desde cero tarda unos 30 minutos.

¿Cómo vigilas el margen y añades números?

Consulta GET /v1/numbers cada pocos minutos. Cada número informa de sus stats y de sus limits, así que puedes sumar el espacio que queda hasta el 80% en los números sanos y avisar de cualquier número que no esté healthy. El webhook number.status_changed te avisa en el momento en que cambian health u online (Webhook de WhatsApp: firma, reintentos y eventos duplicados).

type Num = {
  number: string;
  status: "provisioning" | "active" | "retired";
  health: "healthy" | "at_risk" | "critical";
  stats: { active_chats_30d: number; new_chats_24h: number; outbound_24h: number };
  limits: { active_chats_30d: number; new_chats_24h: number; outbound_24h: number };
};

/** Espacio libre en los números sanos, contado hasta el 80% de cada límite. */
export async function headroom() {
  const res = await fetch(`${API}/numbers`, { headers });
  const { data } = (await res.json()) as { data: Num[] };
  const live = data.filter((n) => n.status === "active");
  const sick = live.filter((n) => n.health !== "healthy").map((n) => n.number);
  const room = { users: 0, signups: 0, sends: 0 };
  for (const n of live.filter((n) => n.health === "healthy")) {
    room.users += Math.max(0, Math.floor(n.limits.active_chats_30d * PLAN) - n.stats.active_chats_30d);
    room.signups += Math.max(0, Math.floor(n.limits.new_chats_24h * PLAN) - n.stats.new_chats_24h);
    room.sends += Math.max(0, Math.floor(n.limits.outbound_24h * PLAN) - n.stats.outbound_24h);
  }
  return { numbers: live.length, sick, room };
}

/** Añade un número. Cobra $49 al instante, así que llámalo detrás de un tope. */
export async function addNumber(label: string): Promise<Num> {
  const res = await fetch(`${API}/numbers`, {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify({ label, profile: { name: "Ava", about: "Tu amiga IA" } }),
  });
  if (res.status === 402) throw new Error("balance too low: top up first");
  if (res.status === 503) throw new Error("no_capacity: nothing charged, retry later");
  if (!res.ok) throw new Error(`add failed with ${res.status}`);
  return (await res.json()) as Num;
}

Llama a addNumber cuando room.users baje de los registros que esperas en las próximas dos semanas, o room.signups baje de tu día más ocupado, y limita el total para que un error no gaste tu saldo. Mantén el saldo por encima de números x $49: un número se renueva solo mientras el saldo lo cubre, y cuando el saldo se acaba tiene 3 días de gracia y después se retira.

Varios productos o clientes

Una cuenta tiene una sola URL de webhook, así que usa un grupo de números por producto, personaje o cliente y distínguelos tú mismo. Dale a cada número una label como tutor-fr-1, configura su perfil (nombre, about, foto) con el personaje y enruta cada evento por su campo number. Ejecuta numbersNeeded por grupo. La facturación es un único saldo, así que cobra a cada cliente su cantidad de números x $49 por tu lado.

¿Cómo se comparan los límites de la Business API?

Meta limita las personas únicas a las que una empresa puede escribir fuera de la ventana de atención al cliente de 24 horas, por cada 24 horas móviles y por portfolio comercial, compartido por todos sus números. Los portfolios nuevos empiezan en 250. La verificación, o enviar 2.000 mensajes entregados con alta calidad, lo sube a 2.000. Después sube automáticamente a 10.000, 100.000 e ilimitado cuando tus mensajes son de alta calidad y usaste al menos la mitad del límite en los últimos 7 días.

La plataforma oficial escala por cuotas, whasp por teléfonos. Las respuestas dentro de la ventana no forman parte del nivel de Meta y no encontramos ningún tope de usuarios activos por número oficial, así que para un agente que Meta admite, un número oficial puede atender a una audiencia muy grande. Si tu IA está permitida allí es la primera pregunta, y el precio de la API de WhatsApp en 2026 muestra lo que cuesta la vía oficial.

Qué hacer ahora

Saca tres números de tus propios registros: usuarios activos en 30 días móviles, registros en tu día más ocupado y mensajes enviados en tu día más ocupado. Ejecuta numbersNeeded y añade los números con un lanzamiento de antelación. Conecta la comprobación de margen y lee por qué WhatsApp banea números para dimensionar tu reserva.