Library for interacting with the WhatsApp Web API . 

Library for interacting with the WhatsApp Web API 

binsee

juzi-admin

@juzi/whatsapp-web.js

  "description": "Library for interacting with the WhatsApp Web API ",

    "test": "mocha tests --recursive --timeout 5000",

    "shell": "node --experimental-repl-await ./shell.js",

    "generate-docs": "node_modules/.bin/jsdoc --configure .jsdoc.json --verbose"

    "url": "git+https://github.com/pedroslopez/whatsapp-web.js.git"

    "url": "https://github.com/pedroslopez/whatsapp-web.js/issues"

    "puppeteer-extra-plugin-anonymize-ua": "^2.4.4",

    "puppeteer-extra-plugin-stealth": "^2.11.1"

const puppeteer = require('puppeteer-extra');

const anonymize = require('puppeteer-extra-plugin-anonymize-ua');

const StealthPlugin = require('puppeteer-extra-plugin-stealth');

const moduleRaid = require('@pedroslopez/moduleraid/moduleraid');

const InterfaceController = require('./util/InterfaceController');

const { WhatsWebURL, DefaultOptions, Events, WAState } = require('./util/Constants');

const { ExposeStore, LoadUtils } = require('./util/Injected');

const ChatFactory = require('./factories/ChatFactory');

const ContactFactory = require('./factories/ContactFactory');

const WebCacheFactory = require('./webCache/WebCacheFactory');

const { ClientInfo, Message, MessageMedia, Contact, Location, UrlLink, ProductMessage, GroupNotification, Label, Call, Buttons, List, Reaction, Chat } = require('./structures');

const LegacySessionAuth = require('./authStrategies/LegacySessionAuth');

const NoAuth = require('./authStrategies/NoAuth');

 * Starting point for interacting with the WhatsApp Web API

 * @param {object} options - Client options

 * @param {AuthStrategy} options.authStrategy - Determines how to save and restore sessions. Will use LegacySessionAuth if options.session is set. Otherwise, NoAuth will be used.

 * @param {string} options.webVersion - The version of WhatsApp Web to use. Use options.webVersionCache to configure how the version is retrieved.

 * @param {object} options.webVersionCache - Determines how to retrieve the WhatsApp Web version. Defaults to a local cache (LocalWebCache) that falls back to latest if the requested version is not found.

 * @param {number} options.authTimeoutMs - Timeout for authentication selector in puppeteer

 * @param {object} options.puppeteer - Puppeteer launch options. View docs here: https://github.com/puppeteer/puppeteer/

 * @param {number} options.qrMaxRetries - How many times should the qrcode be refreshed before giving up

 * @param {string} options.restartOnAuthFail  - @deprecated This option should be set directly on the LegacySessionAuth.

 * @param {object} options.session - @deprecated Only here for backwards-compatibility. You should move to using LocalAuth, or set the authStrategy to LegacySessionAuth explicitly. 

 * @param {number} options.takeoverOnConflict - If another whatsapp web session is detected (another browser), take over the session in the current browser

 * @param {number} options.takeoverTimeoutMs - How much time to wait before taking over the session

 * @param {string} options.userAgent - User agent to use in puppeteer

 * @param {string} options.ffmpegPath - Ffmpeg path to use when formating videos to webp while sending stickers 

 * @param {boolean} options.bypassCSP - Sets bypassing of page's Content-Security-Policy.

 * @param {object} options.proxyAuthentication - Proxy Authentication object.

        this.options = Util.mergeDefault(DefaultOptions, options);

            if(Object.prototype.hasOwnProperty.call(this.options, 'session')) {

                    'options.session is deprecated and will be removed in a future release due to incompatibility with multi-device. ' +

                    'Use the LocalAuth authStrategy, don\'t pass in a session as an option, or suppress this warning by using the LegacySessionAuth strategy explicitly (see https://wwebjs.dev/guide/authentication.html#legacysessionauth-strategy).',

                this.authStrategy = new LegacySessionAuth({

                    session: this.options.session,

                    restartOnAuthFail: this.options.restartOnAuthFail

                this.authStrategy = new NoAuth();

            this.authStrategy = this.options.authStrategy;

        Util.setFfmpegPath(this.options.ffmpegPath);

     * Sets up events and requirements, kicks off authentication request

        let [browser, page] = [null, null];

        await this.authStrategy.beforeBrowserInitialized();

                            window.qrChanged(mut.target.dataset.ref);

                        } else if (mut.type === 'childList') {

                        // Listens to retry button, when found, click it

                        if (mut.type === 'childList') {

                            const retry_button = document.querySelector(selectors.QR_RETRY_BUTTON);

                            if (retry_button) retry_button.click();

                obs.observe(qr_container.parentElement, {

                    attributeFilter: ['data-ref'],

                await page.waitForSelector(INTRO_IMG_SELECTOR, { timeout: 0 });

                    error.name === 'ProtocolError' && 

                    error.message.match(/Target closed/)

                    // something has called .destroy() while waiting

        await page.evaluate(ExposeStore, moduleRaid.toString());

        const authEventPayload = await this.authStrategy.getAuthEventPayload();

         * Emitted when authentication is successful

        this.emit(Events.AUTHENTICATED, authEventPayload);

        await page.waitForFunction('window.Store != undefined');

        await page.evaluate(async () => {

            // safely unregister service workers

            const registrations = await navigator.serviceWorker.getRegistrations();

            for (let registration of registrations) {

                registration.unregister();

        //Load util functions (serializers, helper functions)

         * Current connection information

        this.info = new ClientInfo(this, await page.evaluate(() => {

            return { ...window.Store.Conn.serialize(), wid: window.Store.User.getMeUser() };

        this.interface = new InterfaceController(this);

        await page.exposeFunction('onAddMessageEvent', msg => {

                const notification = new GroupNotification(this, msg);

                if (msg.subtype === 'add' || msg.subtype === 'invite') {

                     * Emitted when a user joins the chat via invite link or is added by an admin.

                     * @event Client#group_join

                     * @param {GroupNotification} notification GroupNotification with more information about the action

                    this.emit(Events.GROUP_JOIN, notification);

                } else if (msg.subtype === 'remove' || msg.subtype === 'leave') {

                     * Emitted when a user leaves the chat or is removed by an admin.

                     * @event Client#group_leave

                    this.emit(Events.GROUP_LEAVE, notification);

                } else if (msg.subtype === 'promote' || msg.subtype === 'demote') {

                     * Emitted when a current user is promoted to an admin or demoted to a regular user.

                     * @event Client#group_admin_changed

                    this.emit(Events.GROUP_ADMIN_CHANGED, notification);

                     * Emitted when group settings are updated, such as subject, description or picture.

                     * @event Client#group_update

                    this.emit(Events.GROUP_UPDATE, notification);

            const result = await window.Store.QueryExist(wid);

            if (!result || result.wid === undefined) return null;

             * The number of the result may be different with the input number.

             * See: https://github.com/juzibot/whatsapp-web.js/issues/23

            if (!result || result.wid === undefined || result.wid._serialized !== number) return null;

     * Get the formatted number of a WhatsApp ID.

     * @param {string} number Number or ID

        if (!number.endsWith('@s.whatsapp.net')) number = number.replace('c.us', 's.whatsapp.net');

        if (!number.includes('@s.whatsapp.net')) number = `${number}@s.whatsapp.net`;

        return await this.pupPage.evaluate(async numberId => {

            return window.Store.NumberInfo.formattedPhoneNumber(numberId);

     * Get the country code of a WhatsApp ID.

        number = number.replace(' ', '').replace('+', '').replace('@c.us', '');

            return window.Store.NumberInfo.findCC(numberId);

     * @param {Array<Contact|string>} participants an array of Contacts or contact IDs to add to the group

     * @returns {string} createRes.gid - ID for the group that was just created

     * @returns {Object.<string,string>} createRes.missingParticipants - participants that were not added to the group. Keys represent the ID for participant that was not added and its value is a status code that represents the reason why participant could not be added. This is usually 403 if the user's privacy settings don't allow you to add them to groups.

    async createGroup(name, participants) {

        if (!Array.isArray(participants) || participants.length == 0) {

            throw 'You need to add at least one other participant to the group';

        if (participants.every(c => c instanceof Contact)) {

            participants = participants.map(c => c.id._serialized);

        const createRes = await this.pupPage.evaluate(async (name, participantIds) => {

            const participantWIDs = participantIds.map(p => window.Store.WidFactory.createWid(p));

            return await window.Store.GroupUtils.createGroup(name, participantWIDs, 0);

        const missingParticipants = createRes.participants.reduce(((missing, c) => {

            const id = c.wid._serialized;

            const statusCode = c.error ? c.error.toString() : '200';

            if (statusCode != 200) return Object.assign(missing, { [id]: statusCode });

        return { gid: createRes.wid, missingParticipants };

        const labels = await this.pupPage.evaluate(async () => {

            return window.WWebJS.getLabels();

        return labels.map(data => new Label(this, data));

        const label = await this.pupPage.evaluate(async (labelId) => {

            return window.WWebJS.getLabel(labelId);

     * Get all Labels assigned to a chat 

        const labels = await this.pupPage.evaluate(async (chatId) => {

            return window.WWebJS.getChatLabels(chatId);

		{
		"name": "@juzi/whatsapp-web.js",
		"version": "1.21.2",
		"version": "1.21.3",
		"description": "Library for interacting with the WhatsApp Web API ",
		@@ -5,0 +5,0 @@ "main": "./index.js",

		@@ -246,5 +246,4 @@ 'use strict';
		window.qrChanged(mut.target.dataset.ref);
		} else
		} else if (mut.type === 'childList') {
		// Listens to retry button, when found, click it
		if (mut.type === 'childList') {
		const retry_button = document.querySelector(selectors.QR_RETRY_BUTTON);
		@@ -1212,3 +1211,7 @@ if (retry_button) retry_button.click();
		const result = await window.Store.QueryExist(wid);
		if (!result \|\| result.wid === undefined) return null;
		/**
		* The number of the result may be different with the input number.
		* See: https://github.com/juzibot/whatsapp-web.js/issues/23
		*/
		if (!result \|\| result.wid === undefined \|\| result.wid._serialized !== number) return null;
		return result.wid;
		@@ -1215,0 +1218,0 @@ }, number);

Improved metrics