@realvare/baileys

v1.0.6

Published

a day ago

Whatsapp api by Sam aka Vare - Based

Downloads

163

0High
0Medium
0Low

realvare

baileys whatsapp whatsapp-api whatsapp-web whatsapp-bot automation multi-device samakavare realvare based vare varebot

Wave

Retro

🚀 Performance Optimization Guide

This section explains the built-in performance optimizations and JID/LID validation improvements.

🎯 Performance Optimizations

The library now includes comprehensive performance optimizations with these default settings:

// Performance settings
{
  enableCache: true,              // Enable caching for faster data retrieval
  batchSize: 50,                  // Process messages in batches of 50
  maxRetries: 3,                  // Maximum reconnection attempts
  retryDelay: 2000,               // Initial retry delay (2 seconds)
  retryBackoffMultiplier: 1.5,    // Exponential backoff multiplier
  maxRetryDelay: 30000,           // Maximum retry delay (30 seconds)
  syncFullHistory: false,         // Disable full history sync to prevent slowdowns
  enableLidLogging: process.env.DEBUG_LID === 'true', // Enable LID logging for debugging if env var is true
  logLevel: process.env.LOG_LEVEL || 'debug'          // Detailed logging for troubleshooting
}

// Cache settings
{
  lidCache: {
    ttl: 180000,                  // 3 minutes TTL
    maxSize: 1000,                // Maximum 1,000 entries
    cleanupInterval: 60000        // Cleanup every 1 minute
  },
  jidCache: {
    ttl: 180000,                  // 3 minutes TTL
    maxSize: 1000,                // Maximum 1,000 entries
    cleanupInterval: 60000        // Cleanup every 1 minute
  },
  lidToJidCache: {
    ttl: 180000,                  // 3 minutes TTL
    maxSize: 500,                 // Maximum 500 entries
    cleanupInterval: 120000       // Cleanup every 2 minutes
  },
  groupMetadataCache: {
    ttl: 300000,                  // 5 minutes TTL
    maxSize: 250,                 // Maximum 250 entries
    cleanupInterval: 180000       // Cleanup every 3 minutes
  }
}

Events behavior: all emitted events (e.g. messages.upsert, messages.update, group-participants.update) will expose standard JIDs (@s.whatsapp.net, @g.us, etc.) in msg.key.remoteJid and msg.key.participant whenever possible. When WhatsApp provides LIDs, the original values are preserved in msg.key.remoteLid and msg.key.participantLid.

📈 Key Benefits

Performance Improvements:

✅ Reduced Latency: Caching reduces repeated API calls by 80-90%
✅ Better Throughput: Batch processing handles message bursts efficiently
✅ Improved Stability: Exponential backoff prevents rapid reconnection attempts
✅ Lower Ban Risk: Disabled full history sync and reduced online presence marking

Error Reduction:

✅ JID/LID Validation: Prevents undefined errors from invalid IDs
✅ Automatic Conversion: Handles WhatsApp's LID format changes seamlessly
✅ Detailed Logging: Helps identify and debug ID-related issues
✅ Graceful Fallback: Maintains functionality even with invalid IDs

🎛️ Usage Example

const { makeWASocket, useMultiFileAuthState } = require('@realvare/baileys');

// Set up authentication
const { state, saveCreds } = await useMultiFileAuthState('auth_info_baileys');

// Create socket
const sock = makeWASocket({
  auth: state,
  printQRInTerminal: true
});

💡 Best Practices

Always validate JIDs before processing messages
Enable caching for production environments
Disable syncFullHistory to prevent performance issues
Use exponential backoff for reconnection attempts
Monitor cache metrics to optimize TTL and size settings
Implement proper error handling for invalid JIDs/LIDs

✨ Main Features

This library, based on Baileys with specific improvements, offers an intuitive API to interact with WhatsApp Web. Here is a summary of the key features:

🚀 Quick Guide

This section includes basic examples for authentication and connection management.

Basic Example - Starting Bot

import makeWASocket, { DisconnectReason, useMultiFileAuthState } from '@realvare/baileys';

async function startBot() {
    // 🔐 Multi-file authentication setup for persistent sessions
    const { state, saveCreds } = await useMultiFileAuthState('auth_info_baileys');

    // 🌐 Socket creation with basic configuration
    const sock = makeWASocket({
        auth: state,
        printQRInTerminal: true,
        logger: console,
        browser: ['VareBot', 'Chrome', '4.0.0'],
    });

    // Improved reconnection system
    let reconnectAttempts = 0;
    const maxRetries = 5;
    const retryDelay = 5000;
    const retryBackoffMultiplier = 1.5;
    const maxRetryDelay = 60000;

    sock.ev.on('connection.update', (update) => {
        const { connection, lastDisconnect } = update;

        if (connection === 'close') {
            const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut;

            if (shouldReconnect) {
                reconnectAttempts++;
                const delay = Math.min(
                    retryDelay * Math.pow(
                        retryBackoffMultiplier,
                        reconnectAttempts - 1
                    ),
                    maxRetryDelay
                );

                console.log(`🔄 Reconnection attempt ${reconnectAttempts}/${maxRetries} in ${delay}ms`);

                if (reconnectAttempts <= maxRetries) {
                    setTimeout(startBot, delay);
                } else {
                    console.log('❌ Maximum number of reconnection attempts reached');
                }
            }
        } else if (connection === 'open') {
            console.log('🟢 Connected successfully!');
            reconnectAttempts = 0;
        }
    });

    sock.ev.on('creds.update', saveCreds);
}startBot().catch(console.error);

Anti-Ban Example - Recommended Configuration to Avoid Bans

import makeWASocket, { DisconnectReason, useMultiFileAuthState, getSenderLid, validateJid } from '@realvare/baileys';

async function startBot() {
    const { state, saveCreds } = await useMultiFileAuthState('auth_info_baileys');

    const sock = makeWASocket({
        auth: state,
        printQRInTerminal: true,
        logger: console,
        browser: ['YourBotName', 'Chrome', '4.0.0'], // Customize browser fingerprint
        markOnlineOnConnect: false, // Crucial: Prevents always appearing online, reduces ban risk
        syncFullHistory: false      // Avoid syncing unnecessary data that could signal activity
    });

    let reconnectAttempts = 0;
    const maxRetries = 5;
    const retryDelay = 5000;
    const retryBackoffMultiplier = 1.5;
    const maxRetryDelay = 60000;

    sock.ev.on('connection.update', (update) => {
        const { connection, lastDisconnect } = update;

        if (connection === 'close') {
            const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut;

            if (shouldReconnect) {
                reconnectAttempts++;
                const delay = Math.min(
                    retryDelay * Math.pow(
                        retryBackoffMultiplier,
                        reconnectAttempts - 1
                    ),
                    maxRetryDelay
                );

                console.log(`Reconnecting attempt ${reconnectAttempts}/${maxRetries} in ${delay}ms`);

                if (reconnectAttempts <= maxRetries) {
                    setTimeout(startBot, delay);
                } else {
                    console.log('Max reconnection attempts reached');
                }
            }
        } else if (connection === 'open') {
            console.log('Connected successfully!');
            reconnectAttempts = 0;
        }
    });

    // Monitor acks through message updates to ensure proper handling
    sock.ev.on('messages.update', (updates) => {
        for (const update of updates) {
            if (update.update.status) {
                console.log(`Message ${update.key.id} status: ${update.update.status}`); // Track acks (1=sent, 2=delivered, 3=read)
                // Add custom logic if necessary, but avoid overriding defaults to prevent detection
            }
        }
    });

    // Advanced LID/JID utilities for ack stability
    sock.ev.on('messages.upsert', ({ messages }) => {
        for (const msg of messages) {
            const info = getSenderLid(msg);
            const validation = validateJid(info.jid);
            if (validation.isValid) {
                // Process and ack safely
                console.log(`Valid JID: ${info.jid}, LID: ${info.lid}`);
            } else {
                console.warn(`Invalid JID detected: ${info.jid}`);
            }
        }
    });

    sock.ev.on('creds.update', saveCreds);
}

startBot().catch(console.error);

📊 Advanced Cache Management

The library now includes an advanced cache system with automatic memory management and configurable TTL:

import { CacheManager } from '@realvare/baileys';

// Example of using the cache
const cache = CacheManager;

// Save a value in the cache
cache.set('lidCache', 'key', 'value', 300 * 1000); // TTL of 300 seconds (in milliseconds)

// Retrieve a value
const value = cache.get('lidCache', 'key');

// Get cache statistics
const stats = cache.getStats('lidCache');
console.log('Cache statistics:', stats);

Advanced Cache Configuration

The cache is pre-configured with optimal settings for production use:

import { CacheManager } from '@realvare/baileys';

// Cache is automatically configured with:
// - lidCache: 3 minutes TTL, 1000 max entries
// - jidCache: 3 minutes TTL, 1000 max entries
// - Automatic cleanup and memory management

// Monitor cache performance
const stats = CacheManager.getStats('lidCache');
console.log('Cache statistics:', stats);

🔍 Troubleshooting

Connection Issues

The library now implements a retry system with exponential backoff
Automatic monitoring of connection status
Configurable reconnection attempts

Memory Management

Automatic monitoring of memory usage
Automatic cache cleanup when necessary
Configurable TTL for each cache type

Advanced Logging

import { Logger } from '@realvare/baileys';

// Use the built-in Logger for conditional logging
Logger.debug('Debug info');
Logger.performance('Performance metrics');
Logger.error('Error occurred');

Basic Message Management with LID/JID

import makeWASocket, { getSenderLid, toJid, getCacheStats, validateJid, Logger } from '@realvare/baileys';

// ... (sock creation code here)

sock.ev.on('messages.upsert', ({ messages }) => {
  for (const msg of messages) {
    // 🔍 Extract sender LID with validation
    const info = getSenderLid(msg);
    
    // ✅ Validate JID before using it
    const validation = validateJid(info.jid);
    if (!validation.isValid) {
      Logger.error('Invalid JID:', validation.error);
      continue;
    }
    
    const jid = toJid(info.lid); // Normalize to JID
    
    Logger.info('💬 Message from:', jid, 'Valid:', info.isValid);
    console.log('📝 Content:', msg.message?.conversation);
    
    // Automatically reply only if valid
    if (info.isValid) {
      sock.sendMessage(jid, { text: 'Message received!' });
    }
  }
  
  // 📊 Monitor cache performance
  const stats = getCacheStats();
  Logger.performance('Cache stats:', stats);
});

📚 API Documentation

This section expands on the main methods, with detailed examples and parameters. All methods are typed in TypeScript for a safe development experience.

🏗️ Fundamental Methods

| Method | Description | Import | |--------|-------------|--------| | makeWASocket(config) | Core: Creates WhatsApp socket | ✅ Included | | useMultiFileAuthState(folder) | Auth: Persistent credentials management | ✅ Included | | getSenderLid(msg) | LID: Extracts LID from message | ✅ Included | | toJid(lid) | JID: Converts LID → JID | ✅ Included | | validateJid(jid) | Validation: Verifies JID | ✅ Included | | getCacheStats() | Performance: Cache statistics | ✅ Included | | clearCache() | Cleanup: Clears cache | ✅ Included |

🔥 Note: All the above methods are ready to use and shown in the Quick Guide. Go directly to the advanced sections for specific features!

📰 Newsletters API

The library supports full interaction with WhatsApp Channels (Newsletters). You can create channels, update metadata, follow/unfollow, and fetch channel messages or updates.

1. Creation and Subscriptions

// Create a new newsletter (channel)
const metadata = await sock.newsletterCreate(
    'My Channel Name', 
    'Description of my channel', 
    { url: './media/cover.png' } // Optional cover picture
);
console.log('Created channel JID:', metadata.id);

// Follow or Unfollow a channel
await sock.newsletterFollow(channelJid);
await sock.newsletterUnfollow(channelJid);

// Mute or Unmute updates from a channel
await sock.newsletterMute(channelJid);
await sock.newsletterUnmute(channelJid);

// Subscribe to live/realtime updates of a channel
await sock.subscribeNewsletterUpdates(channelJid);

2. Manage Channel Details

// Update Channel Name
await sock.newsletterUpdateName(channelJid, 'New Channel Name');

// Update Channel Description
await sock.newsletterUpdateDescription(channelJid, 'Updated description text');

// Update/Remove Channel Cover Picture
await sock.newsletterUpdatePicture(channelJid, { url: './media/new_cover.jpg' });
await sock.newsletterRemovePicture(channelJid);

// Retrieve Channel Metadata
const info = await sock.newsletterMetadata('jid', channelJid);
console.log('Channel details:', info.name, info.subscribers, info.reaction_codes);

3. Messages & Reactions

// React to a channel message (omit reaction code to remove the reaction)
await sock.newsletterReactMessage(channelJid, serverId, '🔥');

// Change allowed reaction mode for followers
// Modes: 'ALL', 'BASIC' (standard set), or 'NONE'
await sock.newsletterReactionMode(channelJid, 'BASIC');

// Fetch messages/posts from a channel (either by jid or invite code)
const messages = await sock.newsletterFetchMessages('jid', channelJid, 10, undefined);

// Fetch updates for existing messages (e.g. view counts, reactions)
const updates = await sock.newsletterFetchUpdates(channelJid, 10, undefined, undefined);

4. Role & Owner Management

// Change channel ownership to another LID (Local ID)
await sock.newsletterChangeOwner(channelJid, userLid);

// Demote an admin back to follower using their LID
await sock.newsletterDemote(channelJid, userLid);

// Get current administrator count
const adminsCount = await sock.newsletterAdminCount(channelJid);

💼 Business Catalog API

Interact with WhatsApp Business features such as catalogs, collections, product management, and verify numbers.

1. Check Banned/Registered Numbers

// Check if a phone number is banned or validly registered on WhatsApp
const check = await sock.numcheck('393514357738');
if (check.banned) {
    console.log(`Number is banned. Reason: ${check.reason}`);
    console.log(`Appeal details: ${check.appeal_token}`);
} else {
    console.log('Number is active and not banned.');
}

2. Get Business Profiles and Catalogs

// Retrieve a business profile details (e.g., business hours, address, etc.)
const profile = await sock.getBusinessProfile(businessJid);

// Retrieve product catalog lists
const catalog = await sock.getCatalog({ jid: businessJid, limit: 10, cursor: undefined });

// Retrieve collections lists
const collections = await sock.getCollections(businessJid, 10);

// Fetch details for an order
const orderDetails = await sock.getOrderDetails(orderId, tokenBase64);

3. Product Catalog Management

// Create a new product in your catalog
const product = await sock.productCreate({
    name: 'New Product',
    description: 'Product Description',
    price: 1500, // represented as priceAmount1000 (e.g., 1.50 EUR = 1500)
    currency: 'EUR',
    image: { url: './media/product.jpg' }
});

// Update an existing product
await sock.productUpdate(product.id, {
    name: 'Updated Product Name',
    price: 2000
});

// Delete products from catalog
await sock.productDelete([product.id]);

🎯 Main Events

| Event | Description | Callback Signature | |---------------------|--------------------------------------|-------------------------------------| | connection.update | Connection status updates | (update: Partial<ConnectionState>) => void | | creds.update | Credentials update | () => void | | messages.upsert | New messages or updates | ({ messages: WAMessage[], type: MessageUpsertType }) => void | | messages.update | Changes to existing messages | (update: WAMessageUpdate[]) => void | | group-participants.update | Group participant changes | (update: GroupParticipantEvent) => void |

Event Registration Example:

conn.ev.on('group-participants.update', (update) => {
  console.log('Participant updated:', update);
});

🎪 Messages and Interactive Features

Basic Messages

Text with Formatting

// Text with formatting and mentions
await conn.sendMessage(jid, { 
    text: `*Bold* _italic_ ~strikethrough~ \`monospace\`\n@mention`, 
    mentions: ['[email protected]'] 
});

Basic Media

// Image
await conn.sendMessage(jid, { 
    image: { url: './media/varebot.jpg' }, // Also supports Buffer
    caption: 'zwag'
});

// Video
await conn.sendMessage(jid, { 
    video: { url: './media/oppastoppa.mp4' },
    caption: 'brrrr',
    gifPlayback: false // true to play as GIF
});

// Audio
await conn.sendMessage(jid, { 
    audio: { url: './media/audio.mp3' },
    mimetype: 'audio/mp4',
    ptt: true // true for voice message, false for normal audio
});

// Document
await conn.sendMessage(jid, { 
    document: { url: './media/doc.pdf' },
    mimetype: 'application/pdf',
    fileName: 'document.pdf'
});

Advanced Media

// Album (Multiple images)
await conn.sendMessage(jid, {
    album: imageBuffers.map(buffer => ({ image: buffer })),
    caption: 'ts gettin real'
});

Sticker Packs

await conn.sendMessage(jid, {
  stickerPack: {
    name: 'My Sticker Pack',
    publisher: 'My Bot',
    description: 'A cool sticker pack',       // Optional: pack description
    cover: { url: './cover.webp' },            // Optional: tray icon (uses first sticker if omitted)
    stickerPackId: 'pack-uuid-here',           // Optional: auto-generated UUID v4 if not provided
    origin: 2,                                 // Optional: 0 = FIRST_PARTY, 1 = THIRD_PARTY, 2 = USER_CREATED (default)
    caption: 'Check out my stickers!',         // Optional
    contextInfo: {},                           // Optional
    stickers: [
      {
        sticker: { url: './sticker1.webp' },   // Buffer, URL or stream
        emojis: ['🎉', '🎊'],                 // Optional: defaults to ['']
        isAnimated: false,                     // Optional: defaults to false
        isLottie: false,                       // Optional: defaults to false
        accessibilityLabel: 'Celebration',     // Optional: defaults to ''
        mimetype: 'image/webp'                 // Optional: auto-detected from upload
        // fileName is auto-generated as base64(sha256(sticker)) + '.webp'
      },
      {
        sticker: { url: './sticker2.webp' },
        emojis: ['😄'],
        isAnimated: false
      },
      {
        sticker: Buffer.from(/* webp data */),
        emojis: ['🔥']
      }
    ]
  }
});

Stickers on Status (2025 Feature)

The new interactive stickers on Status (e.g., with lyrics or questions) can be sent by sending a sticker to status@broadcast.

await conn.sendMessage('status@broadcast', {
  sticker: { url: './sticker.webp' },
  caption: 'Interactive sticker on Status'
}, { statusJidList: ['[email protected]', '[email protected]'] });

Interactive Messages

These messages include interactive elements like buttons, lists, polls, carousels, collections, and invoices.

Messages with Simple Buttons

Send quick reply buttons.

await conn.sendMessage(jid, {
  text: 'Choose an option:',
  footer: 'Footer',
  buttons: [
    { buttonId: 'cmd1', buttonText: { displayText: 'Option 1' }, type: 1 },
    { buttonId: 'cmd2', buttonText: { displayText: 'Option 2' }, type: 1 },
  ],
});

Messages with Buttons and Image

Combine an image with buttons.

await conn.sendMessage(jid, {
  image: { url: 'https://i.ibb.co/hJW7WwxV/varebot.jpg' },
  caption: 'Message with buttons and image',
  footer: 'vare ✧ bot',
  buttons: [
    { buttonId: 'cmd', buttonText: { displayText: 'text1' }, type: 1 },
  ],
});

List Messages

Send a list of options (only in private chats).

await conn.sendMessage(jid, {
  text: 'This is a list!',
  footer: 'purplepurplepurple!',
  title: 'List Title',
  buttonText: 'View List',
  sections: [
    { 
      title: 'Section 1', 
      rows: [ 
        { title: 'Option 1', rowId: 'opt1',description: 'Descriptionx' }, 
        { title: 'Option 2', rowId: 'opt2', description: 'Descriptiony' } 
      ] 
    },
  ],
});

Collection Messages (Catalog)

Send a collection/catalog message to browse products.

await conn.sendMessage(jid, {
  text: 'Browse our catalog!',
  footer: 'Shop now',
  title: 'Our Products',
  collection: {
    bizJid: '[email protected]',
    id: 'catalog123',
    messageVersion: 1
  }
});

Invoice Messages

Send an invoice with attachment (image or PDF).

await conn.sendMessage(jid, {
  invoice: {
    note: 'Invoice for your order',
    token: 'invoice_token_123',
    attachmentType: 1, // 0 = IMAGE, 1 = PDF
    attachment: { url: './invoice.pdf' } // or image
  }
});

Carousel Messages with Card Types

Send a carousel of cards with different card types.

await conn.sendMessage(jid, {
  text: 'Check out these options!',
  footer: 'Swipe to see more',
  cards: [
    {
      title: 'Card 1',
      body: 'Description 1',
      footer: 'Footer 1',
      image: { url: './image1.jpg' },
      buttons: [
        { name: 'quick_reply', buttonParamsJson: '{"display_text":"Button 1"}' }
      ]
    },
    {
      title: 'Card 2',
      body: 'Description 2',
      video: { url: './video.mp4' }
    }
  ],
  carouselCardType: 1 // 1 = HSCROLL_CARDS (horizontal scroll), 2 = ALBUM_IMAGE - futureproof
});

Interactive Messages with Audio Footer

Send interactive messages with audio in the footer.

await conn.sendMessage(jid, {
  text: 'Listen to this message!',
  title: 'Audio Message',
  interactiveButtons: [
    { name: 'action1', buttonParamsJson: '{"display_text":"Action"}' }
  ],
  footer: {
    text: 'Footer text',
    audio: { url: './audio.mp3' } // Audio attachment in footer
  }
});

Interactive Messages with Product Header

Send interactive messages with a product in the header.

await conn.sendMessage(jid, {
  text: 'Check out this product!',
  title: 'Featured Product',
  interactiveButtons: [
    { name: 'buy', buttonParamsJson: '{"display_text":"Buy Now"}' }
  ],
  headerProduct: {
    productImage: { url: './product.jpg' },
    productId: 'prod123',
    title: 'Product Name',
    description: 'Product Description',
    currency: 'EUR',
    priceAmount1000: 10000
  }
});

Interactive Response Messages

Send responses to interactive messages (e.g., Native Flow responses).

await conn.sendMessage(jid, {
  interactiveResponse: {
    body: {
      text: 'Response text',
      format: 0 // 0 = DEFAULT, 1 = EXTENSIONS_1
    },
    nativeFlowResponse: {
      name: 'flow_name',
      paramsJson: '{"key":"value"}',
      version: 1
    },
    contextInfo: {
      mentionedJid: [jid]
    }
  }
});

Poll Messages

Create a poll for users to vote on.

await conn.sendMessage(jid, { 
  poll: { 
    name: 'Favorite Anime?', 
    values: ['Aot', 'Bleach', 'Death note'], 
    selectableCount: 1 // or >1 for multi-select
  } 
});

Poll Result Snapshot

Send a snapshot of poll results.

await conn.sendMessage(jid, {
  pollResultSnapshot: {
    name: 'Favorite Anime?',
    pollVotes: [
      { optionName: 'Aot', optionVoteCount: 10 },
      { optionName: 'Bleach', optionVoteCount: 5 },
      { optionName: 'Death note', optionVoteCount: 3 }
    ],
    pollType: 0, // 0 = POLL, 1 = QUIZ
    contextInfo: {
      mentionedJid: [jid]
    }
  }
});

Poll Update

Send a poll vote update.

await conn.sendMessage(jid, {
  pollUpdate: {
    pollCreationMessageKey: {
      remoteJid: jid,
      fromMe: false,
      id: 'pollMessageId123'
    },
    vote: {
      encPayload: Buffer.from('encrypted_vote_payload'),
      encIv: Buffer.from('encryption_iv')
    },
    senderTimestampMs: Date.now()
  }
});

Comment Messages

Comment on a specific message in a chat.

await conn.sendMessage(jid, {
  comment: {
    message: { text: 'This is a comment!' },
    targetMessageKey: {
      remoteJid: jid,
      fromMe: false,
      id: 'messageId123'
    }
  }
});

Question Messages

Create a question message that users can respond to.

await conn.sendMessage(jid, {
  question: {
    text: 'What is your favorite programming language?',
    contextInfo: {
      mentionedJid: [jid]
    }
  }
});

Question Response Messages

Respond to a question message.

await conn.sendMessage(jid, {
  questionResponse: {
    key: {
      remoteJid: jid,
      fromMe: false,
      id: 'questionMessageId123'
    },
    text: 'My answer is TypeScript!'
  }
});

Status Question Answer Messages

Answer a question posted on status.

await conn.sendMessage('status@broadcast', {
  statusQuestionAnswer: {
    key: {
      remoteJid: 'status@broadcast',
      fromMe: false,
      id: 'statusQuestionId123'
    },
    text: 'My answer to the status question'
  }
}, {
  statusJidList: [jid]
});

Status Quoted Messages

Quote a status message (e.g., question-answer reshare).

await conn.sendMessage('status@broadcast', {
  statusQuoted: {
    type: 1, // QUESTION_ANSWER
    text: 'This is my response',
    thumbnail: buffer, // optional thumbnail
    originalStatusId: {
      remoteJid: 'status@broadcast',
      fromMe: false,
      id: 'originalStatusId123'
    }
  }
}, {
  statusJidList: [jid]
});

Status Sticker Interaction Messages

Interact with stickers on status (e.g., reactions).

await conn.sendMessage('status@broadcast', {
  statusStickerInteraction: {
    key: {
      remoteJid: 'status@broadcast',
      fromMe: false,
      id: 'statusMessageId123'
    },
    stickerKey: 'stickerKey123',
    type: 1 // REACTION
  }
}, {
  statusJidList: [jid]
});

AI Rich Response Messages

The library provides native support for GenAI-style Rich Response messages (which render with rich styling, tables, code blocks, etc. on supported WhatsApp clients). There are two ways to send them:

Option A: `sendMessage` richResponse syntax

You can pass a richResponse option inside sendMessage. This can be either a single layout object or an array of layout objects (supporting texts, tokenized codes, tables, lists, and LaTeX formulas):

Single Object layout (Text and Code snippet):

await sock.sendMessage(jid, {
  richResponse: {
    text: 'Here is the result of your calculation:', // Optional Markdown text
    code: 'def add(a, b):\n    return a + b',          // Optional code snippet
    language: 'python',                               // Optional code language (default 'javascript')
    botJid: '867051314767696@bot'                     // Optional GenAI bot identity JID
  }
});

Array of Layout blocks (mixing text, code, tables, lists, LaTeX):

await sock.sendMessage(jid, {
  richResponse: [
    { text: 'Here is the detailed project overview:' },
    { 
      code: 'const name = "Based";\nconsole.log(name);', 
      language: 'javascript' 
    },
    {
      table: {
        title: 'Project Statistics',
        headers: ['Metric', 'Value'],
        rows: [
          ['Status', 'Active'],
          ['Version', '1.0.6']
        ],
        footer: 'Generated automatically'
      }
    },
    {
      list: {
        title: 'Next Tasks',
        items: ['Deploy release', 'Run benchmarks', 'Update docs'],
        footer: 'Priority High'
      }
    }
  ]
});

Option B: Socket Helper Methods

The socket instance exposes helper methods to construct and send tables, lists, and code blocks instantly:

// 1. Send a beautiful Code Block (tokenized automatically)
await sock.sendCodeBlock(jid, 'const a = 12;\nconsole.log(a);', quotedMsg, {
  title: 'JavaScript Code',
  footer: 'Run in Node.js',
  language: 'javascript'
});

// 2. Send a formatted Data Table
await sock.sendTable(
  jid,
  'Project Statistics',
  ['Metric', 'Value'],
  [
    ['Errors Resolved', '14'],
    ['Coverage', '94%']
  ],
  quotedMsg,
  { headerText: 'Here is the automated report:', footer: 'Generated on build.' }
);

// 3. Send a simplified List
await sock.sendList(
  jid,
  'Shopping List',
  ['Milk', 'Apples', 'Coffee'],
  quotedMsg,
  { headerText: 'Items to buy:', footer: 'ASAP' }
);

// 4. Send LaTeX Expressions
await sock.sendLatex(jid, quotedMsg, {
  text: 'LaTeX Formula representation:',
  expressions: [
    { 
      latexExpression: 'e^{i\\pi} + 1 = 0', 
      url: 'https://example.com/math.png', // URL of the rendered image
      width: 200, 
      height: 50 
    }
  ],
  headerText: 'Mathematics',
  footer: 'Formulas'
});

// 5. Send Generic Rich Responses (combining manual submessages)
await sock.sendRichMessage(jid, [
  {
    messageType: 2, // TEXT
    messageText: 'This is custom text before the table'
  },
  {
    messageType: 4, // TABLE
    tableMetadata: {
      title: 'Custom Table',
      rows: [
        { items: ['Name', 'Role'], isHeading: true },
        { items: ['Sam', 'Owner'] }
      ]
    }
  }
], quotedMsg);

Note: AI rich responses may show as "not supported" on some older WhatsApp clients depending on app version and account feature availability.

Other Messages

Business Call Messages (BCall)

Send business call messages with media.

await conn.sendMessage(jid, {
  bCall: {
    sessionId: 'call_session_123',
    mediaType: 2, // 0 = UNKNOWN, 1 = AUDIO, 2 = VIDEO
    masterKey: Buffer.from('master_key_bytes'),
    caption: 'Business call'
  }
});

Call Log Messages

Send call log information.

await conn.sendMessage(jid, {
  callLog: {
    isVideo: true,
    callOutcome: 0, // 0 = CONNECTED, 1 = MISSED, 2 = FAILED, 3 = REJECTED, etc.
    durationSecs: 120,
    callType: 0, // 0 = REGULAR, 1 = SCHEDULED_CALL, 2 = VOICE_CHAT
    participants: [
      { jid: '[email protected]', callOutcome: 0 }
    ]
  }
});

Event Response Messages

Respond to an event message (e.g., RSVP for an event).

await conn.sendMessage(jid, {
  eventResponse: {
    response: 1, // GOING = 1, NOT_GOING = 2, MAYBE = 3
    timestampMs: Date.now(),
    extraGuestCount: 0
  }
});

Status Mention Messages

Mention a status in another status.

await conn.sendMessage('status@broadcast', {
  statusMention: {
    quotedStatus: {
      key: {
        remoteJid: 'status@broadcast',
        fromMe: false,
        id: 'statusId123'
      },
      message: {
        conversation: 'Original status message'
      }
    }
  }
}, {
  statusJidList: [jid]
});

Group Status Messages

Send a status message specific to a group.

await conn.sendMessage(jid, {
  groupStatus: {
    message: {
      conversation: 'Group status update!'
    }
  }
});

Bot Task Messages

Send a message related to a bot task.

await conn.sendMessage(jid, {
  botTask: {
    message: {
      conversation: 'Bot task completed.'
    }
  }
});

Limit Sharing Messages

Send a message to limit sharing.

await conn.sendMessage(jid, {
  limitSharing: {
    message: {
      conversation: 'Sharing limited for this message.'
    }
  }
});

Status Add Yours Messages

Send a "Add Yours" status message.

await conn.sendMessage('status@broadcast', {
  statusAddYours: {
    message: {
      conversation: 'Add yours to this trend!'
    }
  }
}, {
  statusJidList: [jid]
});

Bot Forwarded Messages

Send a message that was forwarded by a bot.

await conn.sendMessage(jid, {
  botForwarded: {
    message: {
      conversation: 'This message was forwarded by a bot.'
    }
  }
});

Event Cover Image Messages

Send a cover image for an event.

await conn.sendMessage(jid, {
  eventCoverImage: {
    message: {
      imageMessage: {
        url: 'https://example.com/event_cover.jpg',
        mimetype: 'image/jpeg'
      }
    }
  }
});

Poll Creation Message V4

Create a poll with additional options (version 4).

await conn.sendMessage(jid, {
  pollV4: {
    name: 'Favorite color (V4)?',
    selectableCount: 1,
    values: ['Red', 'Green', 'Blue'],
    pollType: 0 // Default poll type
  }
});

Poll Creation Message V5

Create a poll with additional options (version 5).

await conn.sendMessage(jid, {
  pollV5: {
    name: 'Favorite food (V5)?',
    selectableCount: 2,
    values: ['Pizza', 'Pasta', 'Sushi'],
    pollType: 1 // Quiz poll type
  }
});

Poll Result Snapshot Message V3

Send a snapshot of poll results (version 3).

await conn.sendMessage(jid, {
  pollResultSnapshotV3: {
    pollCreationMessageKey: {
      remoteJid: jid,
      fromMe: true,
      id: 'pollMessageId123'
    },
    pollResult: {
      vote: {
        selectedOptions: [Buffer.from('Red')]
      },
      senderTimestampMs: Date.now()
    },
    contextInfo: {
      mentionedJid: [jid]
    },
    pollType: 0 // Default poll type
  }
});

Encrypted Comment Messages

Send encrypted comments on messages.

await conn.sendMessage(jid, {
  encComment: {
    targetMessageKey: {
      remoteJid: jid,
      fromMe: false,
      id: 'messageId123'
    },
    encPayload: Buffer.from('encrypted_payload'),
    encIv: Buffer.from('encryption_iv')
  }
});

Encrypted Event Response Messages

Send encrypted event responses.

await conn.sendMessage(jid, {
  encEventResponse: {
    eventCreationMessageKey: {
      remoteJid: jid,
      fromMe: false,
      id: 'eventMessageId123'
    },
    encPayload: Buffer.from('encrypted_payload'),
    encIv: Buffer.from('encryption_iv')
  }
});

Message History Bundle

Send a bundle of message history.

await conn.sendMessage(jid, {
  messageHistoryBundle: {
    mimetype: 'application/octet-stream',
    media: { url: './history.bundle' },
    messageHistoryMetadata: {
      historyReceivers: ['[email protected]', '[email protected]'],
      oldestMessageTimestamp: Date.now() - 86400000,
      messageCount: 100
    },
    contextInfo: {
      mentionedJid: [jid]
    }
  }
});

Message History Notice

Send a notice about message history.

await conn.sendMessage(jid, {
  messageHistoryNotice: {
    messageHistoryMetadata: {
      historyReceivers: ['[email protected]'],
      oldestMessageTimestamp: Date.now() - 86400000,
      messageCount: 50
    },
    contextInfo: {
      mentionedJid: [jid]
    }
  }
});

Newsletter Follower Invite

Invite followers to a newsletter.

await conn.sendMessage(jid, {
  inviteFollower: {
    newsletterJid: '120363418582531215@newsletter',
    newsletterName: 'My Newsletter',
    thumbnail: buffer, // Optional thumbnail
    caption: 'Join our newsletter!',
    contextInfo: {
      mentionedJid: [jid]
    }
  }
});

Placeholder Messages

Send placeholder messages (e.g., to mask linked devices).

await conn.sendMessage(jid, {
  placeholder: {
    type: 0 // MASK_LINKED_DEVICES = 0
  }
});

Secret Encrypted Messages

Send secret encrypted messages (for event or message edits).

await conn.sendMessage(jid, {
  secretEncrypted: {
    targetMessageKey: {
      remoteJid: jid,
      fromMe: false,
      id: 'targetMessageId123'
    },
    encPayload: Buffer.from('encrypted_payload'),
    encIv: Buffer.from('encryption_iv'),
    secretEncType: 2 // 0 = UNKNOWN, 1 = EVENT_EDIT, 2 = MESSAGE_EDIT
  }
});

Status Notification Messages

Send status notification messages (for status interactions).

await conn.sendMessage('status@broadcast', {
  statusNotification: {
    responseMessageKey: {
      remoteJid: 'status@broadcast',
      fromMe: false,
      id: 'responseId123'
    },
    originalMessageKey: {
      remoteJid: 'status@broadcast',
      fromMe: false,
      id: 'originalId123'
    },
    type: 1 // 0 = UNKNOWN, 1 = STATUS_ADD_YOURS, 2 = STATUS_RESHARE, 3 = STATUS_QUESTION_ANSWER_RESHARE
  }
}, {
  statusJidList: [jid]
});

Sticker Sync RMR Messages

Sync stickers via RMR (Recent Media Request).

await conn.sendMessage(jid, {
  stickerSyncRMR: {
    filehash: ['hash1', 'hash2', 'hash3'],
    rmrSource: 'source_identifier',
    requestTimestamp: Date.now()
  }
});

// Payment Messages

Request Payment

await conn.sendMessage(jid, {
    requestPayment: {
        currency: 'EUR',
        amount1000: 5000,
        requestFrom: '[email protected]',
        note: 'js gimme my money' // https://paypal.me/samakavare
    }
});

Send Payment

await conn.sendMessage(jid, {
    sendPayment: {
        requestMessageKey: {
            remoteJid: jid,
            fromMe: false,
            id: 'paymentRequestId123'
        },
        noteMessage: { text: 'Payment sent' },
        background: {
            id: 'payment_bg_id',
            type: 1 // DEFAULT = 1
        },
        transactionData: 'transaction_data_string'
    }
});

Decline Payment Request

await conn.sendMessage(jid, {
    declinePayment: {
        key: {
            remoteJid: jid,
            fromMe: false,
            id: 'paymentRequestId123'
        }
    }
});

Cancel Payment Request

await conn.sendMessage(jid, {
    cancelPayment: {
        key: {
            remoteJid: jid,
            fromMe: true,
            id: 'paymentRequestId123'
        }
    }
});

Scheduled Call Creation

await conn.sendMessage(jid, {
    call: {
        callKey: {
            fromMe: true,
            id: Date.now().toString(),
            remoteJid: jid
        },
        type: 'ACCEPT',  // 'MISSED', 'OFFER', 'ACCEPT', 'REJECT'..
        time: Date.now() + 3600000, // Scheduled time (optional)
        title: 'Team Meeting' // Optional title
    }
});

Scheduled Call Edit

await conn.sendMessage(jid, {
    scheduledCallEdit: {
        key: {
            remoteJid: jid,
            fromMe: true,
            id: 'scheduledCallId123'
        },
        editType: 1 // 0 = UNKNOWN, 1 = CANCEL
    }
});

Pin/Unpin Messages

Pin or unpin a message in a chat.

// Pin a message (type 1 = PIN_FOR_ALL)
await conn.sendMessage(jid, {
    pin: {
        key: {
            remoteJid: jid,
            fromMe: false,
            id: 'messageId123'
        },
        type: 1, // 1 = PIN_FOR_ALL, 2 = UNPIN_FOR_ALL
        time: 86400 // Duration in seconds (24 hours = 86400, 7 days = 604800, 30 days = 2592000)
    }
});

// Or use simplified syntax
await conn.sendMessage(jid, {
    pin: {
        remoteJid: jid,
        fromMe: false,
        id: 'messageId123'
    },
    type: 1, // 1 = PIN_FOR_ALL, 2 = UNPIN_FOR_ALL
    time: 86400 // Optional: duration in seconds
});

// Unpin a message (type 2 = UNPIN_FOR_ALL)
await conn.sendMessage(jid, {
    pin: {
        key: {
            remoteJid: jid,
            fromMe: false,
            id: 'messageId123'
        },
        type: 2 // UNPIN_FOR_ALL
    }
});

Response Management

To manage responses to interactive messages, use the messages.upsert listener and check the response type:

conn.ev.on('messages.upsert', async ({ messages }) => {
    const msg = messages[0];
    
    // Button response
    if (msg.message?.buttonsResponseMessage) {
        const selectedId = msg.message.buttonsResponseMessage.selectedButtonId;
        console.log(`Selected button: ${selectedId}`);
    }
    
    // List response
    if (msg.message?.listResponseMessage) {
        const selectedId = msg.message.listResponseMessage.singleSelectReply.selectedRowId;
        console.log(`Selected option: ${selectedId}`);
    }
    
    // Poll response
    if (msg.message?.pollResponseMessage) {
        const selectedOptions = msg.message.pollResponseMessage.selectedOptions;
        console.log('Selected options:', selectedOptions);
    }
    
    // Comment response
    if (msg.message?.commentMessage) {
        const comment = msg.message.commentMessage;
        console.log('Comment on message:', comment.targetMessageKey?.id);
        console.log('Comment content:', comment.message);
    }
    
    // Question response
    if (msg.message?.questionResponseMessage) {
        const response = msg.message.questionResponseMessage;
        console.log('Response to question:', response.key?.id);
        console.log('Answer:', response.text);
    }
    
    // Status question answer
    if (msg.message?.statusQuestionAnswerMessage) {
        const answer = msg.message.statusQuestionAnswerMessage;
        console.log('Status question answer:', answer.text);
    }
    
    // AI Rich Response
    if (msg.message?.richResponseMessage) {
        const richResponse = msg.message.richResponseMessage;
        console.log('AI Rich Response type:', richResponse.messageType);
        console.log('Submessages:', richResponse.submessages);
    }
    
    // Interactive Response (Native Flow Response)
    if (msg.message?.interactiveResponseMessage) {
        const response = msg.message.interactiveResponseMessage;
        console.log('Interactive response body:', response.body?.text);
        if (response.nativeFlowResponseMessage) {
            console.log('Native flow response:', response.nativeFlowResponseMessage.name);
            console.log('Params:', response.nativeFlowResponseMessage.paramsJson);
        }
    }
    
    // Sticker Pack
    if (msg.message?.stickerPackMessage) {
        const pack = msg.message.stickerPackMessage;
        console.log('Sticker pack:', pack.name);
        console.log('Publisher:', pack.publisher);
        console.log('Stickers count:', pack.stickers?.length);
        console.log('Pack ID:', pack.stickerPackId);
        console.log('Origin:', pack.stickerPackOrigin);
    }
    
    // Collection/Catalog response
    if (msg.message?.interactiveMessage?.collectionMessage) {
        const collection = msg.message.interactiveMessage.collectionMessage;
        console.log('Collection opened:', collection.id);
        console.log('Business JID:', collection.bizJid);
    }
    
    // Invoice response
    if (msg.message?.invoiceMessage) {
        const invoice = msg.message.invoiceMessage;
        console.log('Invoice token:', invoice.token);
        console.log('Invoice note:', invoice.note);
        console.log('Attachment type:', invoice.attachmentType === 0 ? 'IMAGE' : 'PDF');
    }
    
    // Business Call
    if (msg.message?.bcallMessage) {
        const bcall = msg.message.bcallMessage;
        console.log('Business call session:', bcall.sessionId);
        console.log('Media type:', bcall.mediaType === 1 ? 'AUDIO' : 'VIDEO');
    }
    
    // Call Log
    if (msg.message?.callLogMesssage) {
        const callLog = msg.message.callLogMesssage;
        console.log('Call outcome:', callLog.callOutcome);
        console.log('Duration:', callLog.durationSecs, 'seconds');
        console.log('Participants:', callLog.participants);
    }
    
    // Encrypted Comment
    if (msg.message?.encCommentMessage) {
        const encComment = msg.message.encCommentMessage;
        console.log('Encrypted comment on message:', encComment.targetMessageKey?.id);
    }
    
    // Encrypted Event Response
    if (msg.message?.encEventResponseMessage) {
        const encEvent = msg.message.encEventResponseMessage;
        console.log('Encrypted event response for:', encEvent.eventCreationMessageKey?.id);
    }
    
    // Message History Bundle
    if (msg.message?.messageHistoryBundle) {
        const bundle = msg.message.messageHistoryBundle;
        console.log('History bundle receivers:', bundle.messageHistoryMetadata?.historyReceivers);
        console.log('Message count:', bundle.messageHistoryMetadata?.messageCount);
    }
    
    // Message History Notice
    if (msg.message?.messageHistoryNotice) {
        const notice = msg.message.messageHistoryNotice;
        console.log('History notice receivers:', notice.messageHistoryMetadata?.historyReceivers);
    }
    
    // Newsletter Follower Invite
    if (msg.message?.newsletterFollowerInviteMessageV2) {
        const invite = msg.message.newsletterFollowerInviteMessageV2;
        console.log('Newsletter invite:', invite.newsletterName);
        console.log('Newsletter JID:', invite.newsletterJid);
    }
    
    // Placeholder
    if (msg.message?.placeholderMessage) {
        const placeholder = msg.message.placeholderMessage;
        console.log('Placeholder type:', placeholder.type);
    }
    
    // Secret Encrypted
    if (msg.message?.secretEncryptedMessage) {
        const secret = msg.message.secretEncryptedMessage;
        console.log('Secret encrypted type:', secret.secretEncType);
        console.log('Target message:', secret.targetMessageKey?.id);
    }
    
    // Status Notification
    if (msg.message?.statusNotificationMessage) {
        const notification = msg.message.statusNotificationMessage;
        console.log('Status notification type:', notification.type);
        console.log('Original message:', notification.originalMessageKey?.id);
    }
    
    // Sticker Sync RMR
    if (msg.message?.stickerSyncRmrMessage) {
        const sync = msg.message.stickerSyncRmrMessage;
        console.log('Sticker sync filehashes:', sync.filehash);
        console.log('RMR source:', sync.rmrSource);
    }
    
    // Send Payment
    if (msg.message?.sendPaymentMessage) {
        const payment = msg.message.sendPaymentMessage;
        console.log('Payment sent for request:', payment.requestMessageKey?.id);
        console.log('Transaction data:', payment.transactionData);
    }
    
    // Decline Payment
    if (msg.message?.declinePaymentRequestMessage) {
        const decline = msg.message.declinePaymentRequestMessage;
        console.log('Payment declined for:', decline.key?.id);
    }
    
    // Cancel Payment
    if (msg.message?.cancelPaymentRequestMessage) {
        const cancel = msg.message.cancelPaymentRequestMessage;
        console.log('Payment cancelled for:', cancel.key?.id);
    }
    
    // Scheduled Call Edit
    if (msg.message?.scheduledCallEditMessage) {
        const edit = msg.message.scheduledCallEditMessage;
        console.log('Scheduled call edited:', edit.key?.id);
        console.log('Edit type:', edit.editType === 1 ? 'CANCEL' : 'UNKNOWN');
    }
    
    // Poll Result Snapshot
    if (msg.message?.pollResultSnapshotMessage) {
        const snapshot = msg.message.pollResultSnapshotMessage;
        console.log('Poll snapshot:', snapshot.name);
        console.log('Votes:', snapshot.pollVotes);
    }
    
    // Poll Update
    if (msg.message?.pollUpdateMessage) {
        const update = msg.message.pollUpdateMessage;
        console.log('Poll update for:', update.pollCreationMessageKey?.id);
    }
    
    // Pin/Unpin
    if (msg.message?.pinInChatMessage) {
        const pin = msg.message.pinInChatMessage;
        console.log('Pin action:', pin.type === 1 ? 'PIN_FOR_ALL' : 'UNPIN_FOR_ALL');
        console.log('Pinned message:', pin.key?.id);
    }
});

🎭 Group Features

Basic Group Management

// Group creation - the jid is for adding participants
const group = await conn.groupCreate('Angels 🩸🕊️', ['[email protected]']);

// Get group info
const metadata = await conn.groupMetadata(jid);

// Get invite code
const code = await conn.groupInviteCode(jid);

// Revoke invite link
await conn.groupRevokeInvite(jid);

// Leave group
await conn.groupLeave(jid);

Participant Management

// Add participants
await conn.groupParticipantsUpdate(
    jid, 
    ['[email protected]'],
    'add'
);

// Remove participants
await conn.groupParticipantsUpdate(
    jid,
    ['[email protected]'],
    'remove'
);

// Promote to admin
await conn.groupParticipantsUpdate(
    jid,
    ['[email protected]'],
    'promote'
);

// Demote from admin
await conn.groupParticipantsUpdate(
    jid,
    ['[email protected]'],
    'demote'
);

// --- Member Approval Requests (Join Approval Mode) ---

// Get list of pending participant join requests
const pendingRequests = await conn.groupRequestParticipantsList(jid);
console.log(pendingRequests); // [{ jid: '[email protected]', rawJid: '[email protected]', ... }]

// Approve or reject pending join requests
const response = await conn.groupRequestParticipantsUpdate(
    jid,
    ['[email protected]'],
    'approve' // or 'reject'
);

// --- V4 Group Invites Management ---

// Revoke a V4 invite for a specific user
await conn.groupRevokeInviteV4(jid, '[email protected]');

// Accept a V4 GroupInviteMessage
// key: remoteJid of sender or WAMessageKey, inviteMessage: groupInviteMessage object
await conn.groupAcceptInviteV4(key, inviteMessage);

Group Settings

// Change group name
await conn.groupUpdateSubject(jid, 'New Name');

// Change description
await conn.groupUpdateDescription(jid, 'New description');

// Change group photo
await conn.updateProfilePicture(jid, { url: './img/group.jpg' });

// Remove group photo
await conn.removeProfilePicture(jid);

// Set group as admin only
await conn.groupSettingUpdate(jid, 'announcement');

// Set group as open to all
await conn.groupSettingUpdate(jid, 'not_announcement');

// Set who can edit info - admin only
await conn.groupSettingUpdate(jid, 'locked');

// Set who can edit info - all
await conn.groupSettingUpdate(jid, 'unlocked');

// Set who can add members - admin only
await conn.groupMemberAddMode(jid, 'admin_add');

// Set who can add members - all
await conn.groupMemberAddMode(jid, 'all_member_add');

// Enable/disable temporary messages (24 hours)
await conn.groupToggleEphemeral(jid, 86400); // seconds

// Disable temporary messages
await conn.groupToggleEphemeral(jid, 0);

// Enable/disable membership approval mode
await conn.groupJoinApprovalMode(jid, 'on'); // requires approval
await conn.groupJoinApprovalMode(jid, 'off'); // open

// Get all groups
const groups = await conn.groupFetchAllParticipating();

// Get pending invites
const invites = await conn.groupGetInviteInfo(code);

// Accept group invite
await conn.groupAcceptInvite(code);

// Get group info from link
const groupInfo = await conn.groupGetInviteInfo('https://chat.whatsapp.com/ABC123');

// Listen to settings changes
conn.ev.on('group-settings.update', async ({ id, announce, restrict }) => {
    if (announce !== undefined) {
        await conn.sendMessage(id, { text: `The group has been set to ${announce ? 'admin only' : 'all'}` });
    }
    if (restrict !== undefined) {
        await conn.sendMessage(id, { text: `Group info can be edited by ${restrict ? 'admin only' : 'all'}` });
    }
});

Advanced Group Messages

// Ghost Message (visible only to specific users in a group)
await conn.sendMessage(jid, {
    text: 'shi made by samakavare using @realvare/baileys',
}, {
    ghostJids: [user1] // Only user1 will be able to decrypt and see this message
});
await conn.sendMessage(jid, {
    text: 'This message will be revealed to everyone in 10 seconds!',
}, {
    ghostJids: [user1, '[email protected]'],
    ghostRevealTimeoutMs: 10000 // Automatically reveals to non-targets after 10s (optional)
});

// Message with multiple mentions
await conn.sendMessage(jid, {
    text: '@user1 @user2 @user3',
    mentions: [user1, user2, user3],
    contextInfo: {
        mentionedJid: [user1, user2, user3]
    }
});

// Message with Google search
await conn.sendMessage(jid, {
    text: 'ZWAG',
    contextInfo: {
        forwardingScore: 999,
        isForwarded: true
    }
});

🔧 Fix LID/JID in Your Own Main and Handler

The LID/JID support is a strength of this library, solving common problems like sender identification in groups and private chats. Here's how to integrate it into your main code and handler.

Best Practices for LID/JID

JID Normalization: The library automatically handles JID/LID normalization in most cases.
Use Built-in Functions: Prefer toJid(), normalizeJid(), and validateJid() from the library.
Cache Management: The library includes automatic caching for LID/JID conversions.

Common Use Cases:

Group Participants: Use toJid() to normalize participant IDs before operations.
Message Sender: Extract sender info with getSenderLid() for reliable identification.
Validation: Alwa