Saltar al contenido principal

Cómo Automatizar Mensajes de Grupo en WhatsApp Cómo Automatizar Mensajes de Grupo en WhatsApp

Cómo Automatizar Mensajes de Grupo en WhatsApp

whatsmeow-node te da control total sobre los grupos de WhatsApp — envía mensajes, menciona miembros, crea grupos, administra participantes y envía difusión a múltiples grupos. Esta guía cubre las tareas de automatización de grupos más comunes.

Requisitos Previos​

  • Una sesión vinculada de whatsmeow-node (Cómo Vincular)
  • Membresía en los grupos a los que quieres enviar mensajes (no puedes enviar a grupos a los que no te has unido)

Listar tus Grupos​

Empieza descubriendo en qué grupos estás:

const groups = await client.getJoinedGroups();

for (const g of groups) {
  console.log(`${g.name} (${g.jid}) — ${g.participants.length} members`);
}

Cada grupo tiene un JID que termina en @g.us — esto es lo que pasas a sendMessage().

Enviar un Mensaje a un Grupo​

Enviar a un grupo funciona igual que enviar a un individuo — solo usa el JID del grupo:

const groupJid = "120363XXXXX@g.us";
await client.sendMessage(groupJid, { conversation: "Hello group!" });

Mencionar Miembros del Grupo​

Mencionar miembros específicos​

Incluye los JID en mentionedJid y usa @<número> en el cuerpo del texto:

const memberJid = "5512345678@s.whatsapp.net";

await client.sendRawMessage(groupJid, {
  extendedTextMessage: {
    text: `Hey @${memberJid.split("@")[0]}, check this out!`,
    contextInfo: {
      mentionedJid: [memberJid],
    },
  },
});

Mencionar a todos​

Obtén los participantes del grupo y construye una lista de menciones:

const group = await client.getGroupInfo(groupJid);
const jids = group.participants.map((p) => p.jid);
const mentions = jids.map((j) => `@${j.split("@")[0]}`).join(" ");

await client.sendRawMessage(groupJid, {
  extendedTextMessage: {
    text: `Attention everyone: ${mentions}`,
    contextInfo: { mentionedJid: jids },
  },
});

Escuchar Eventos de Grupo​

Reacciona a cambios en tus grupos:

// Member changes and setting updates
client.on("group:info", (event) => {
  if (event.join) {
    console.log(`New members in ${event.jid}: ${event.join.join(", ")}`);
    // Welcome new members
    for (const newMember of event.join) {
      client.sendRawMessage(event.jid, {
        extendedTextMessage: {
          text: `Welcome @${newMember.split("@")[0]}!`,
          contextInfo: { mentionedJid: [newMember] },
        },
      });
    }
  }

  if (event.leave) {
    console.log(`Left ${event.jid}: ${event.leave.join(", ")}`);
  }

  if (event.name) {
    console.log(`Group renamed to: ${event.name}`);
  }
});

// When you're added to a new group
client.on("group:joined", ({ jid, name }) => {
  console.log(`Joined group: ${name} (${jid})`);
});

Responder a Mensajes de Grupo​

Maneja los mensajes de forma diferente según si son de un grupo:

client.on("message", async ({ info, message }) => {
  if (info.isFromMe) return;
  if (!info.isGroup) return; // Only handle group messages

  const text =
    (message.conversation as string) ??
    (message.extendedTextMessage as { text?: string } | undefined)?.text;
  if (!text) return;

  // In groups, info.chat is the group JID, info.sender is the person
  console.log(`[${info.chat}] ${info.pushName}: ${text}`);

  if (text === "!members") {
    const group = await client.getGroupInfo(info.chat);
    const list = group.participants
      .map((p) => `- ${p.jid}${p.isAdmin ? " (admin)" : ""}`)
      .join("\n");
    await client.sendMessage(info.chat, {
      conversation: `Members:\n${list}`,
    });
  }
});

Difusión a Múltiples Grupos​

Envía el mismo mensaje a varios grupos con un delay para evitar límites de tasa:

const groups = await client.getJoinedGroups();
const targetGroups = groups.filter((g) => g.name.startsWith("Team "));

for (const group of targetGroups) {
  await client.sendMessage(group.jid, {
    conversation: "Weekly reminder: standup at 9 AM tomorrow",
  });

  // Wait between sends to avoid rate limiting
  await new Promise((r) => setTimeout(r, 2000));
}

console.log(`Sent to ${targetGroups.length} groups`);
Límites de tasa

WhatsApp limita la tasa de envío, especialmente en masa. Espacia los mensajes de 1 a 3 segundos. Enviar demasiado rápido puede hacer que tu cuenta sea restringida temporalmente. Consulta Límites de Tasa.

Crear y Configurar Grupos​

Crear un grupo​

const newGroup = await client.createGroup("Project Alpha", [
  "5512345678@s.whatsapp.net",
  "5598765432@s.whatsapp.net",
]);

console.log(`Created group: ${newGroup.name} (${newGroup.jid})`);

Configurar ajustes​

await client.setGroupDescription(groupJid, "Discussion for Project Alpha");
await client.setGroupAnnounce(groupJid, true);  // Only admins can send
await client.setGroupLocked(groupJid, true);     // Only admins can edit info

Administrar participantes​

// Add members
await client.updateGroupParticipants(groupJid, [newMemberJid], "add");

// Promote to admin
await client.updateGroupParticipants(groupJid, [memberJid], "promote");

// Remove a member
await client.updateGroupParticipants(groupJid, [memberJid], "remove");

Compartir un enlace de invitación​

const link = await client.getGroupInviteLink(groupJid);
console.log(`Invite link: ${link}`);

// Reset the link (invalidates the old one)
const newLink = await client.getGroupInviteLink(groupJid, true);

Ejemplo Completo​

Un bot de administración de grupo que maneja comandos y da la bienvenida a nuevos miembros:

import { createClient } from "@whatsmeow-node/whatsmeow-node";

const client = createClient({ store: "session.db" });

client.on("error", (err) => console.error("Error:", err));

// Welcome new members
client.on("group:info", async (event) => {
  if (!event.join) return;

  for (const jid of event.join) {
    await client.sendRawMessage(event.jid, {
      extendedTextMessage: {
        text: `Welcome @${jid.split("@")[0]}! Type !help for available commands.`,
        contextInfo: { mentionedJid: [jid] },
      },
    });
  }
});

// Handle group commands
client.on("message", async ({ info, message }) => {
  if (info.isFromMe || !info.isGroup) return;

  const text =
    (message.conversation as string) ??
    (message.extendedTextMessage as { text?: string } | undefined)?.text;
  if (!text?.startsWith("!")) return;

  await client.markRead([info.id], info.chat, info.sender);
  const command = text.toLowerCase().trim();

  if (command === "!help") {
    await client.sendMessage(info.chat, {
      conversation: "Commands:\n!help — show this message\n!members — list members\n!invite — get invite link",
    });
  }

  if (command === "!members") {
    const group = await client.getGroupInfo(info.chat);
    const list = group.participants
      .map((p) => {
        const role = p.isSuperAdmin ? "owner" : p.isAdmin ? "admin" : "member";
        return `- @${p.jid.split("@")[0]} (${role})`;
      })
      .join("\n");

    await client.sendRawMessage(info.chat, {
      extendedTextMessage: {
        text: `Members (${group.participants.length}):\n${list}`,
        contextInfo: {
          mentionedJid: group.participants.map((p) => p.jid),
        },
      },
    });
  }

  if (command === "!invite") {
    const link = await client.getGroupInviteLink(info.chat);
    await client.sendMessage(info.chat, { conversation: link });
  }
});

async function main() {
  const { jid } = await client.init();
  if (!jid) {
    console.error("Not paired! See: How to Pair WhatsApp");
    process.exit(1);
  }

  await client.connect();
  await client.sendPresence("available");
  console.log("Group bot is online!");

  process.on("SIGINT", async () => {
    await client.sendPresence("unavailable");
    await client.disconnect();
    client.close();
    process.exit(0);
  });
}

main().catch(console.error);

Errores Comunes​

Envía a info.chat, no a info.sender

En grupos, info.chat es el JID del grupo e info.sender es el individuo. Siempre responde a info.chat — enviar a info.sender inicia una conversación privada.

Grupos de solo anuncios

Si un grupo tiene announce: true, solo los administradores pueden enviar mensajes. Tu bot debe ser admin para enviar mensajes en esos grupos.

Límites de tasa en difusiones

Enviar el mismo mensaje a muchos grupos demasiado rápido activará el limitador de tasa de WhatsApp. Siempre agrega un delay (1-3 segundos) entre envíos. Consulta Límites de Tasa.

Operaciones de admin de grupo

updateGroupParticipants con "promote", "demote" o "remove" requiere que tu bot sea administrador del grupo. "add" también puede requerir permisos de admin dependiendo de la configuración del grupo.

Related Guides

Build a BotBuild a Bot

Build a Bot

Create a WhatsApp bot from scratch — receive messages, handle commands, send replies.

Send Messages from TypeScriptSend Messages from TypeScript

Send Messages from TypeScript

Text, replies, mentions, media, polls, and reactions — all with full type safety.

Send NotificationsSend Notifications

Send Notifications

Send alerts, reminders, and updates to WhatsApp from any Node.js app.

Poll BotPoll Bot

Poll Bot

Create polls, decrypt votes, tally results, and announce winners.