makeWASocket

Main function to create a WhatsApp Web socket connection

Overview

makeWASocket is the primary function used to create a WhatsApp Web socket connection. It accepts a configuration object and returns a socket instance with all methods for interacting with the WhatsApp Web API.

Function Signature

const makeWASocket = (config: UserFacingSocketConfig) => WASocket

Parameters

config · UserFacingSocketConfig · required

Configuration object for the socket connection. This is a combination of Partial<SocketConfig> with a required auth property.

Show UserFacingSocketConfig properties

auth · AuthenticationState · required

Authentication state object to maintain the auth state. Use useMultiFileAuthState() to create this.

version · WAVersion · default: "[2, 3000, 1033846690]"

WhatsApp Web version to connect with. Array of three numbers [major, minor, patch].

browser · WABrowserDescription · default: "Browsers.macOS('Chrome')"

Browser description as a tuple [OS, Browser, Version]. Use the Browsers constant for predefined configurations.

waWebSocketUrl · string | URL · default: "'wss://web.whatsapp.com/ws/chat'"

The WebSocket URL to connect to WhatsApp.

connectTimeoutMs · number · default: "20000"

Timeout in milliseconds for the connection. Fails the connection if the socket times out.

defaultQueryTimeoutMs · number | undefined · default: "60000"

Default timeout for queries in milliseconds. Set to undefined for no timeout.

keepAliveIntervalMs · number · default: "30000"

Ping-pong interval for WebSocket connection in milliseconds.

logger · ILogger · default: "logger.child({ class: 'baileys' })"

Logger instance for debugging and logging.

agent · Agent

HTTPS proxy agent for the WebSocket connection.

fetchAgent · Agent

Agent used for fetch requests when uploading/downloading media.

emitOwnEvents · boolean · default: "true"

Whether events should be emitted for actions done by this socket connection.

customUploadHosts · MediaConnInfo['hosts'] · default: "[]"

Custom upload hosts to upload media to.

retryRequestDelayMs · number · default: "250"

Time to wait between sending new retry requests in milliseconds.

maxMsgRetryCount · number · default: "5"

Maximum retry count for failed messages.

qrTimeout · number

Time to wait for the generation of the next QR code in milliseconds.

shouldSyncHistoryMessage · (msg: proto.Message.IHistorySyncNotification) => boolean

Function to manage history processing. Default syncs everything except FULL sync type.

transactionOpts · TransactionCapabilityOptions

Transaction capability options for SignalKeyStore.

markOnlineOnConnect · boolean · default: "true"

Marks the client as online whenever the socket successfully connects.

countryCode · string · default: "'US'"

Alphanumeric country code (e.g., USA -> US) for the number used.

mediaCache · CacheStore

Cache to store media, so it doesn’t have to be re-uploaded.

msgRetryCounterCache · CacheStore

Map to store retry counts for failed messages; used to determine whether to retry a message.

userDevicesCache · PossiblyExtendedCacheStore

Cache to store a user’s device list.

callOfferCache · CacheStore

Cache to store call offers.

placeholderResendCache · CacheStore

Cache to track placeholder resends.

linkPreviewImageThumbnailWidth · number · default: "192"

Width for link preview images in pixels.

syncFullHistory · boolean · default: "true"

Whether Baileys should ask the phone for full history (received async).

fireInitQueries · boolean · default: "true"

Whether Baileys should fire init queries automatically.

generateHighQualityLinkPreview · boolean · default: "false"

Generate high quality link preview by uploading the jpegThumbnail to WhatsApp.

enableAutoSessionRecreation · boolean · default: "true"

Enable automatic session recreation for failed messages.

enableRecentMessageCache · boolean · default: "true"

Enable recent message caching for retry handling.

shouldIgnoreJid · (jid: string) => boolean | undefined · default: "() => false"

Function that returns if a JID should be ignored. No event for that JID will be triggered and messages from that JID will not be decrypted.

patchMessageBeforeSending · Function · default: "msg => msg"

Optionally patch the message before sending out.

(msg: proto.IMessage, recipientJids?: string[]) => 
  Promise<PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID> |
  PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID

appStateMacVerification · object · default: "{ patch: false, snapshot: false }"

Verify app state MACs.

Show properties

patch · boolean · default: "false"

Verify patch MACs.

snapshot · boolean · default: "false"

Verify snapshot MACs.

options · RequestInit · default: "{}"

Options for HTTP fetch requests.

getMessage · (key: WAMessageKey) => Promise<proto.IMessage | undefined> · default: "async () => undefined"

Fetch a message from your store. Implement this so that messages that failed to send can be retried. Solves the “this message can take a while” issue.

cachedGroupMetadata · (jid: string) => Promise<GroupMetadata | undefined> · default: "async () => undefined"

Cached group metadata function to prevent redundant requests to WhatsApp and speed up message sending.

makeSignalRepository · Function · default: "makeLibSignalRepository"

Function to create signal repository.

(auth: SignalAuthState, logger: ILogger, 
 pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>) => 
  SignalRepositoryWithLIDStore

Return Value

sock · WASocket

Returns a socket instance with all methods for interacting with the WhatsApp Web API, including:

• Message sending and receiving
• Group management
• Contact management
• Media handling
• Event listeners
• And more

Basic Example

import makeWASocket, { useMultiFileAuthState } from '@whiskeysockets/baileys'

const { state, saveCreds } = await useMultiFileAuthState('auth_info_baileys')

const sock = makeWASocket({
  auth: state,
  printQRInTerminal: true
})

// Listen for connection updates
sock.ev.on('connection.update', (update) => {
  const { connection, lastDisconnect } = update
  if(connection === 'close') {
    console.log('Connection closed')
  } else if(connection === 'open') {
    console.log('Connection opened')
  }
})

// Save credentials when updated
sock.ev.on('creds.update', saveCreds)

Advanced Example with Caching

import makeWASocket, { 
  useMultiFileAuthState,
  makeCacheableSignalKeyStore,
  fetchLatestBaileysVersion 
} from '@whiskeysockets/baileys'
import NodeCache from '@cacheable/node-cache'
import P from 'pino'

const logger = P({ level: 'trace' })
const msgRetryCounterCache = new NodeCache()

const { state, saveCreds } = await useMultiFileAuthState('baileys_auth_info')
const { version } = await fetchLatestBaileysVersion()

const sock = makeWASocket({
  version,
  logger,
  auth: {
    creds: state.creds,
    keys: makeCacheableSignalKeyStore(state.keys, logger),
  },
  msgRetryCounterCache,
  generateHighQualityLinkPreview: true,
  getMessage: async (key) => {
    // Implement message retrieval from your store
    return undefined
  }
})

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

Pairing Code Example

import makeWASocket, { useMultiFileAuthState } from '@whiskeysockets/baileys'

const { state, saveCreds } = await useMultiFileAuthState('auth_info')

const sock = makeWASocket({
  auth: state,
  printQRInTerminal: false // Must be false for pairing code
})

if (!sock.authState.creds.registered) {
  const phoneNumber = '1234567890' // Without + or () or -
  const code = await sock.requestPairingCode(phoneNumber)
  console.log(`Pairing code: ${code}`)
}

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

Implementation Details

The makeWASocket function internally:

1. Merges the provided config with DEFAULT_CONNECTION_CONFIG
2. Creates a socket through the makeCommunitiesSocket layer
3. Returns the fully configured socket instance

const makeWASocket = (config: UserFacingSocketConfig) => {
  const newConfig = {
    ...DEFAULT_CONNECTION_CONFIG,
    ...config
  }
  return makeCommunitiesSocket(newConfig)
}

See Also

• SocketConfig - Complete socket configuration reference
• Browsers - Browser configuration options
• Events - Available socket events