Baileys

https://github.com/whiskeysockets/baileys
Admin
Baileys is a WebSockets-based TypeScript library for interacting with the WhatsApp Web API,...
Tokens:195,342
Snippets:1,012
Trust Score:7.8
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### Usage example with makeCacheableSignalKeyStore and addTransactionCapability

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/auth-state.md

Shows how to combine both functions to create a transactional key store with caching, then run a transaction that sets session data and gets a pre-key.

```typescript
import { makeCacheableSignalKeyStore, addTransactionCapability } from '@whiskeysockets/baileys'

const keys = addTransactionCapability(
	makeCacheableSignalKeyStore(mySqlStore, logger),
	logger,
	{ maxCommitRetries: 10, delayBetweenTriesMs: 3000 }
)

await keys.transaction(async () => {
	await keys.set({ session: { [jid]: sessionBytes } })
	const { [jid]: preKey } = await keys.get('pre-key', ['3'])
}, jid)
```

--------------------------------

### Run example script

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Commands to run the example script after cloning the repository. Run them in order from the project root.

```bash
cd path/to/Baileys
```

```bash
yarn
```

```bash
yarn example
```

--------------------------------

### Start WhatsApp connection with auth storage

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Complete example to start a WhatsApp connection with basic auth storage using useMultiFileAuthState. Handles connection updates, reconnection on unexpected close, and replies to incoming messages. For reliable serialization of the authentication state, especially when storing as JSON, always use the BufferJSON utility.

```ts
import makeWASocket, { DisconnectReason, useMultiFileAuthState } from '@whiskeysockets/baileys'
import { Boom } from '@hapi/boom'

async function connectToWhatsApp () {
    const { state, saveCreds } = await useMultiFileAuthState('auth_info_baileys')
    const sock = makeWASocket({
        // can provide additional config here
        auth: state,
        printQRInTerminal: true
    })
    sock.ev.on('connection.update', (update) => {
        const { connection, lastDisconnect } = update
        if(connection === 'close') {
            const shouldReconnect = (lastDisconnect.error as Boom)?.output?.statusCode !== DisconnectReason.loggedOut
            console.log('connection closed due to ', lastDisconnect.error, ', reconnecting ', shouldReconnect)
            // reconnect if not logged out
            if(shouldReconnect) {
                connectToWhatsApp()
            }
        } else if(connection === 'open') {
            console.log('opened connection')
        }
    })
    sock.ev.on('messages.upsert', event => {
        for (const m of event.messages) {
            console.log(JSON.stringify(m, undefined, 2))

            console.log('replying to', m.key.remoteJid)
            await sock.sendMessage(m.key.remoteJid!, { text: 'Hello Word' })
        }
    })

    // to storage creds (session info) when it updates
    sock.ev.on('creds.update', saveCreds)
}
// run in main file
connectToWhatsApp()
```

--------------------------------

### Install stable version

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Install the stable version of the Baileys library.

```bash
yarn add @whiskeysockets/baileys
```

--------------------------------

### Install edge version

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Install the edge version from GitHub. No guarantee of stability but includes latest fixes and features.

```bash
yarn add github:WhiskeySockets/Baileys
```

--------------------------------

### Usage example: catalog pagination and product creation

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/business-socket.md

Example of using makeWASocket to paginate the catalog and create a product with images. Shows how to use the cursor for pagination and the productCreate method.

```typescript
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

// catalog pagination
const { data } = await sock.getCatalog({ limit: 10 })
const cursor = data.paging.cursors.after
const nextPage = await sock.getCatalog({ limit: 10, cursor })

// create a product with images
const product = await sock.productCreate({
	name: 'T-Shirt',
	description: 'cotton tee',
	price: 15.5,
	currency: 'USD',
	originCountryCode: 'US',
	images: [{ url: './tee.png' }]
})
console.log('created', product.id)
```

--------------------------------

### Usage Examples

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/messages-send.md

Examples of sending messages with quotes, mentions, media, read receipts, and error handling.

```APIDOC
## Usage Examples

### Basic text + quoted reply

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

const sent = await sock.sendMessage('15551234567@s.whatsapp.net', { text: 'hello word' })
// quote another message
await sock.sendMessage('15551234567@s.whatsapp.net', { text: 'replying' }, { quoted: originalMessage })
// mention
await sock.sendMessage('15551234567@s.whatsapp.net', {
    text: 'Hey @15551234567',
    mentions: ['15551234567@s.whatsapp.net']
})
console.log(sent.key.id)
```

### Media with upload options, and read receipts

```ts
await sock.sendMessage(jid, { image: { url: './ma_img.png' }, caption: 'hi' }, { mediaUploadTimeoutMs: 20_000 })

// mark a group of messages as read
await sock.readMessages([
    { remoteJid: jid, id: '3EB0…', fromMe: false },
    { remoteJid: jid, id: '3EB0…2', fromMe: false }
])
```

### Error handling around sends (receipts & retries)

```ts
try {
    await sock.sendMessage(jid, { text: 'important!' })
} catch (err) {
    // Boom 463 = account restricted / missing tctoken — do NOT retry
    // Boom 479 = smax-invalid — stale device session/addressing
    if (err instanceof Boom && err.output?.statusCode === 463) {
        console.error('account restricted; cannot start new chats')
    }
}
```
```

--------------------------------

### Enable Corepack and install dependencies

Source: https://github.com/whiskeysockets/baileys/blob/master/AGENTS.md

Enables Corepack and installs dependencies. Required because this repo uses Yarn 4 via Corepack; Yarn 1/classic will fail on package.json resolutions.

```bash
corepack enable
yarn install
```

--------------------------------

### Baileys socket usage example

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/chats-socket.md

Complete usage example showing how to import makeWASocket, fetch privacy settings, block a number, star a message, add a chat label, and archive a chat with the last message. Demonstrates error handling for block failures and uses the auth object for authentication.

```typescript
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

// read receipts/privacy
const privacy = await sock.fetchPrivacySettings(true)
await sock.updateReadReceiptsPrivacy('none')

// block a number
try {
	await sock.updateBlockStatus('15551234567@s.whatsapp.net', 'block')
} catch (err) {
	// Boom 400: unable to resolve LID for PN
	console.error('block failed', err)
}

// star a message and add a chat label
await sock.star('15551234567@s.whatsapp.net', [{ id: '3EB0ABC…', fromMe: false }], true)
await sock.addChatLabel('15551234567@s.whatsapp.net', '5')

// archive with last message
const lastMsg = await getLastMessageFromStore('15551234567@s.whatsapp.net')
await sock.chatModify({ archive: true, lastMessages: [lastMsg] }, '15551234567@s.whatsapp.net')
```

--------------------------------

### Example Debug Log Output for WhatsApp Frame

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Example debug log output showing a WhatsApp message frame. The `frame` has three components: `tag`, `attrs`, and `content`. This example shows a battery status message with an `edge_routing` tag.

```json
{
    "level": 10,
    "fromMe": false,
    "frame": {
        "tag": "ib",
        "attrs": {
            "from": "@s.whatsapp.net"
        },
        "content": [
            {
                "tag": "edge_routing",
                "attrs": {},
                "content": [
                    {
                        "tag": "routing_info",
                        "attrs": {},
                        "content": {
                            "type": "Buffer",
                            "data": [8,2,8,5]
                        }
                    }
                ]
            }
        ]
    },
    "msg":"communication"
}
```

--------------------------------

### Conventional commit examples

Source: https://github.com/whiskeysockets/baileys/blob/master/AGENTS.md

Example commit messages following the Conventional Commits format, scoped where useful. PR titles follow the same convention and squash-merge is the default.

```text
feat(socket): add support for reachout limits XWAs
fix(retry): process <keys> bundle and embed SKDM on resend
chore(deps): bump ajv from 6.12.6 to 6.15.0
test(e2e): test harness + signal/prekey fixes
```

--------------------------------

### Start socket with QR-CODE

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Initializes a WhatsApp socket that displays a QR code in the terminal for authentication. You can customize the browser identity using the Browsers constant.

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({
    // can provide additional config here
    browser: Browsers.ubuntu('My App'),
    printQRInTerminal: true
})
```

--------------------------------

### Get BlockList with fetchBlocklist

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Fetches the blocklist and logs the response.

```ts
const response = await sock.fetchBlocklist()
console.log(response)
```

--------------------------------

### Usage example: Fetch account reachout timelock and new chat message cap

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/endpoints.md

Initializes a WhatsApp socket and calls two WMex RPC endpoints to exercise the reach-out timelock and capping endpoints. Logs the returned properties for each response.

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

// WMex RPC — exercise the reach-out timelock and capping endpoints
const timelock = await sock.fetchAccountReachoutTimelock()
console.log(timelock.isActive, timelock.enforcementType)

const cap = await sock.fetchNewChatMessageCap()
console.log(cap.capping_status, cap.used_quota, cap.total_quota)
```

--------------------------------

### Error handling with products

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/business-socket.md

Example of error handling when updating and deleting products. Catches errors raised by query() when the IQ returns an <error> child.

```typescript
try {
	await sock.productUpdate(product.id, { description: 'updated' })
	const del = await sock.productDelete([product.id])
	console.log(`deleted ${del.deleted}`)
} catch (err) {
	// Boom raised by query() when the IQ returns an <error> child
	console.error('catalog mutation failed', err)
}
```

--------------------------------

### Start socket with Pairing Code

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Authenticates using a phone number instead of a QR code. The phone number must include the country code and contain only digits.

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({
    // can provide additional config here
    printQRInTerminal: false //need to be false
})

if (!sock.authState.creds.registered) {
    const number = 'XXXXXXXXXXX'
    const code = await sock.requestPairingCode(number)
    console.log(code)
}
```

--------------------------------

### Usage example: fetchMessageHistory and rejectCall

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/messages-recv.md

Shows how to fetch earlier history when the phone is online and reject an incoming call. The call event provides callId and callFrom.

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

// fetch earlier history when the phone is online
await sock.fetchMessageHistory(50, oldestMsg.key, oldestMsg.messageTimestamp)

// reject an incoming call (callId/callFrom from the `call` event)
sock.ev.on('call', ([call]) => {
	if (call.status === 'offer') {
		void sock.rejectCall(call.id, call.from)
	}
})
```

--------------------------------

### createCallLink

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/chats-socket.md

Creates a call link for an audio or video call. Optionally accepts an event start time and a timeout in milliseconds. Returns the call link as a string, or undefined if creation fails.

```APIDOC
## createCallLink

### Description
Creates a call link for an audio or video call. Optionally accepts an event start time and a timeout in milliseconds. Returns the call link as a string, or undefined if creation fails.

### Method
createCallLink

### Signature
```ts
createCallLink(type: 'audio' | 'video', event?: { startTime: number }, timeoutMs?: number): Promise<string | undefined>
```

### Parameters
- **type** ('audio' | 'video') - Required - The type of call link to create.
- **event** ({ startTime: number }) - Optional - An object containing the start time of the event.
- **timeoutMs** (number) - Optional - Timeout in milliseconds for the operation.

### Returns
Promise<string | undefined> - The call link as a string, or undefined if creation fails.
```

--------------------------------

### Custom USync query with status and LID protocols

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/usync.md

Example of creating a custom USync query to check status and LID for multiple phone numbers. It imports makeWASocket and USync classes, builds a query with protocols and users, executes it, and iterates over the results.

```typescript
import makeWASocket from '@whiskeysockets/baileys'
import { USyncQuery, USyncUser } from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

// custom query: check status + LID for several PNs
const query = new USyncQuery()
	.withStatusProtocol()
	.withLIDProtocol()
	.withContext('background')
	.withUser(new USyncUser().withId('15551234567@s.whatsapp.net'))
	.withUser(new USyncUser().withId('15557654321@s.whatsapp.net'))

const result = await sock.executeUSyncQuery(query)
for (const entry of result?.list ?? []) {
	console.log(entry.id, entry.status, entry.lid)
}
```

--------------------------------

### Basic connect, listen, and reply with makeWASocket

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/makeWASocket.md

Shows how to initialize a socket with multi-file auth state, listen for connection updates and incoming messages, and reply with 'pong'. Also saves credentials on 'creds.update'.

```typescript
import makeWASocket from '@whiskeysockets/baileys'
import { useMultiFileAuthState } from '@whiskeysockets/baileys'

const { state, saveCreds } = await useMultiFileAuthState('./auth')
const sock = makeWASocket({ auth: state })

sock.ev.on('connection.update', ({ connection }) => {
	if (connection === 'open') console.log('connected!')
})

sock.ev.on('messages.upsert', ({ messages }) => {
	for (const m of messages) {
		console.log('got message', m.key.remoteJid, m.message)
		void sock.sendMessage(m.key.remoteJid!, { text: 'pong' })
	}
})

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

--------------------------------

### Listen to socket events

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/event-buffer.md

Demonstrates how to initialize a socket and subscribe to various event types like connection updates, message upserts, and messaging history status.

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

sock.ev.on('connection.update', update => {
	if (update.receivedPendingNotifications) console.log('caught up on offline events')
	if (update.isOnline === false) console.log('shown offline to others')
})

sock.ev.on('messages.upsert', ({ messages, type }) => {
	console.log(type, messages.length)          // 'notify' | 'append'
})

sock.ev.on('messaging-history.status', ({ syncType, status, explicit }) => {
	console.log(`history ${syncType} ${status} (explicit=${explicit})`)
})
```

--------------------------------

### Import makeWASocket

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/makeWASocket.md

Shows how to import makeWASocket as both a default and named export from the package.

```ts
import makeWASocket, { makeWASocket as namedMakeWASocket } from '@whiskeysockets/baileys'
```

--------------------------------

### USyncQueryProtocol interface

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/usync.md

Defines the USyncQueryProtocol interface that all protocol classes implement. It requires a name, a method to get the query element, a method to get the user element, and a parser function.

```typescript
export interface USyncQueryProtocol {
	name: string
	getQueryElement: () => BinaryNode
	getUserElement: (user: USyncUser) => BinaryNode | null
	parser: (data: BinaryNode) => unknown
}
```

--------------------------------

### Use JID helpers (jidDecode, jidNormalizedUser, areJidsSameUser)

Source: https://github.com/whiskeysockets/baileys/blob/master/AGENTS.md

Always use JID helpers instead of string ops. JIDs carry device suffixes, agent fields, and LID/PN duality; string ops silently miss matches on multi-device accounts.

```ts
import { jidDecode, jidNormalizedUser, areJidsSameUser, isJidUser } from '../WABinary'

const decoded = jidDecode(rawJid)            // { user, server, device?, agent? } | undefined
const normalized = jidNormalizedUser(rawJid) // strips device/agent, lowercases
const same = areJidsSameUser(a, b)           // compare user portions only
```

--------------------------------

### productCreate

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/business-socket.md

Creates a new product in the catalog.

```APIDOC
## productCreate

### Description
Creates a new product in the catalog.

### Method
Not specified (likely a socket method)

### Endpoint
Not applicable (socket method)

### Parameters
#### Request Body
- **name** (string) - Required - Product name
- **retailerId** (string) - Optional - Retailer ID
- **url** (string) - Optional - Product URL
- **description** (string) - Required - Product description
- **price** (number) - Required - Product price
- **currency** (string) - Required - Currency code
- **isHidden** (boolean) - Optional - Whether the product is hidden
- **originCountryCode** (string) - Required - Origin country code
- **images** (WAMediaUpload[]) - Required - Product images

### Response
#### Success Response
- Returns a `Promise<Product>`

### Response Example
Not provided in source.
```

--------------------------------

### Use Multi-File Auth State with makeWASocket

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/auth-state.md

Sets up a WhatsApp socket with multi-file auth state and saves credentials on updates. Requires the 'auth_info_baileys' folder.

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

const { state, saveCreds } = await useMultiFileAuthState('auth_info_baileys')
const sock = makeWASocket({ auth: state })
sock.ev.on('creds.update', saveCreds)
```

--------------------------------

### Get Privacy Settings with fetchPrivacySettings

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Fetches the current privacy settings and logs them to the console.

```ts
const privacySettings = await sock.fetchPrivacySettings(true)
console.log('privacy settings: ' + privacySettings)
```

--------------------------------

### Get All Participating Groups Metadata with groupFetchAllParticipating

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Fetches metadata for all groups the current user participates in. Logs the response.

```ts
const response = await sock.groupFetchAllParticipating()
console.log(response)
```

--------------------------------

### Get Request Join List with groupRequestParticipantsList

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Retrieves the list of users who have requested to join the group. Logs the response.

```ts
const response = await sock.groupRequestParticipantsList(jid)
console.log(response)
```

--------------------------------

### Minimal makeWASocket with auth and custom store

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/configuration.md

Creates a WhatsApp socket with multi-file auth state, a custom browser, and various options like syncing full history, online status, and event emission. Includes a custom message store, cached group metadata, transaction options, and app state MAC verification.

```ts
import makeWASocket, { useMultiFileAuthState, Browsers } from '@whiskeysockets/baileys'
import { LRUCache } from 'lru-cache'

const { state } = await useMultiFileAuthState('./auth')

const sock = makeWASocket({
	auth: state,
	browser: Browsers.appropriate('Chrome'),
	syncFullHistory: false,
	markOnlineOnConnect: false,
	emitOwnEvents: true,
	shouldIgnoreJid: (jid) => jid === '15550000000@s.whatsapp.net',
	getMessage: async (key) => myMessageStore.get(key),
	cachedGroupMetadata: async (jid) => groupCache.get(jid),
	transactionOpts: { maxCommitRetries: 5, delayBetweenTriesMs: 1000 },
	appStateMacVerification: { patch: true, snapshot: true }
})
```

--------------------------------

### requestPairingCode(phoneNumber, customPairingCode?)

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/makeWASocket.md

Starts a pairing-code login. Throws if customPairingCode length is not 8. Returns the pairing code.

```APIDOC
## requestPairingCode(phoneNumber, customPairingCode?)

### Description
Starts a pairing-code login. Throws `Error('Custom pairing code must be exactly 8 chars')` if `customPairingCode` has a length other than 8. The returned string is the pairing code to type into the phone.

### Method
`requestPairingCode(phoneNumber: string, customPairingCode?: string): Promise<string>`

### Parameters
- **phoneNumber** (string) - Required - The phone number to pair.
- **customPairingCode** (string) - Optional - Custom pairing code (must be exactly 8 characters).

### Returns
- **Promise<string>** - The pairing code.

```

--------------------------------

### appPatch(patchCreate: WAPatchCreate): Promise<void>

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/chats-socket.md

Applies a patch to the app state. Throws an error if the app state key is missing.

```APIDOC
## appPatch(patchCreate: WAPatchCreate): Promise<void>

### Description
Applies a patch to the app state. Throws `Boom('App state key not present!', { statusCode: 400 })` when `creds.myAppStateKeyId` is missing. It serializes through an internal mutex; when `config.emitOwnEvents`, the resulting mutations are emitted locally.

### Method
Function call

### Parameters
- **patchCreate** (WAPatchCreate) - Required - The patch to apply.

### Returns
- **Promise<void>** - Resolves when the patch is applied.

### Error Handling
- **400** - Throws Boom error if app state key is missing.
```

--------------------------------

### Get Group Info by Invite Code with groupGetInviteInfo

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Fetches group information using an invite code. Logs the group information.

```ts
const response = await sock.groupGetInviteInfo(code)
console.log('group information: ' + response)
```

--------------------------------

### Get order details

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/business-socket.md

Fetches order details for a given order ID and token. Returns OrderDetails parsed via parseOrderDetailsNode.

```typescript
getOrderDetails(orderId: string, tokenBase64: string): Promise<OrderDetails>
```

--------------------------------

### makeLibSignalRepository

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/signal-crypto.md

Factory function to create the default Signal repository implementation.

```APIDOC
## makeLibSignalRepository

### Description
Creates the default Signal repository implementation that wires the libsignal library to the SignalKeyStore, sender-key store, and LID mapping store. This is the default `config.makeSignalRepository` implementation.

### Method
Function

### Signature
```ts
export function makeLibSignalRepository(
	auth: SignalAuthState,
	logger: ILogger,
	pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>
): SignalRepositoryWithLIDStore
```

### Parameters
- **auth** (SignalAuthState) - Required - The authentication state containing signal keys.
- **logger** (ILogger) - Required - Logger instance for logging.
- **pnToLIDFunc** (function) - Optional - Function to map phone numbers to LID mappings.

### Returns
- **SignalRepositoryWithLIDStore** - The signal repository with LID store.

```

--------------------------------

### Fetch Business Profile with sock.getBusinessProfile

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Fetch a business profile, including its description and category.

```ts
const profile = await sock.getBusinessProfile(jid)
console.log('business description: ' + profile.description + ', category: ' + profile.category)
```

--------------------------------

### Product CRUD methods

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/business-socket.md

Methods to create, update, and delete products. Both create and update first upload new images via uploadingNecessaryImagesOfProduct, then send product_catalog_add / product_catalog_edit IQs. productDelete returns the number deleted from the deleted_count attribute.

```typescript
productCreate(create: ProductCreate): Promise<Product>
productUpdate(productId: string, update: ProductUpdate): Promise<Product>
productDelete(productIds: string[]): Promise<{ deleted: number }>
```

--------------------------------

### Get Group Invite Code with groupInviteCode

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Retrieves the group invite code. To create a full invite link, prepend 'https://chat.whatsapp.com/' to the code.

```ts
const code = await sock.groupInviteCode(jid)
console.log('group code: ' + code)
```

--------------------------------

### Catalog methods

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/business-socket.md

Methods to fetch the product catalog and collections. getCatalog defaults jid to the authenticated user's id, limit to 10, and requests width/height 100. getCollections fetches collections with collection_limit/item_limit = limit (default 51).

```typescript
getCatalog({ jid, limit, cursor }: GetCatalogOptions): Promise<CatalogResult>
getCollections(jid?: string, limit = 51): Promise<CollectionsResult>
```

--------------------------------

### Create and manage a newsletter channel

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/newsletter-socket.md

Shows how to create a newsletter channel, follow it, update its description, and fetch metadata by invite code using the WASocket methods.

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

// create + follow
const channel = await sock.newsletterCreate('My Channel', 'announcements only')
await sock.newsletterFollow(channel.id)
await sock.newsletterUpdateDescription(channel.id, 'updated description')

// fetch metadata by invite code
const byInvite = await sock.newsletterMetadata('invite', channel.invite!)
console.log(byInvite.name, byInvite.subscribers)
```

--------------------------------

### Aggregate decrypted poll votes

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/message-utils.md

Example of aggregating decrypted poll votes from poll updates. It uses decryptPollVote and getAggregateVotesInPollMessage, and requires a getMessage implementation to fetch the poll message.

```ts
import { decryptPollVote, getAggregateVotesInPollMessage } from '@whiskeysockets/baileys'

sock.ev.on('messages.update', async ([{ key, update }]) => {
	if (!update.pollUpdates) return
	const pollMessage = await getMessageFromStore(key) // your getMessage implementation
	const votes = update.pollUpdates.map(u => decryptPollVote(pollMessage, u, sock.user.id))
	console.log(getAggregateVotesInPollMessage({ message: pollMessage, pollUpdates: update.pollUpdates }))
})
```

--------------------------------

### Send view-once image message with viewOnce flag

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Sends a view-once message by passing viewOnce: true in the content object. This works with video and audio messages as well.

```ts
await sock.sendMessage(
    id,
    {
        image: {
            url: './Media/ma_img.png'
        },
        viewOnce: true, //works with video, audio too
        caption: 'hello word'
    }
)
```

--------------------------------

### Download media with re-upload fallback

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/message-utils.md

Example of downloading an image message as a stream using downloadMediaMessage, with reuploadRequest set to sock.updateMediaMessage for re-upload fallback. The code listens for 'messages.upsert' events and processes each message.

```ts
import { downloadMediaMessage, getContentType } from '@whiskeysockets/baileys'

sock.ev.on('messages.upsert', async ({ messages }) => {
	for (const m of messages) {
		if (!m.message) continue
		if (getContentType(m.message) === 'imageMessage') {
			const stream = await downloadMediaMessage(
				m, 'stream', { }, { reuploadRequest: sock.updateMediaMessage }
			)
			// pipe stream to disk…
		}
	}
})
```

--------------------------------

### Fetch Profile Picture with sock.profilePictureUrl

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Get the display picture URL of a person or group. The first call returns a low-resolution picture; the second call with the `'image'` argument returns a high-resolution picture.

```ts
// for low res picture
const ppUrl = await sock.profilePictureUrl(jid)
console.log(ppUrl)

// for high res picture
const ppUrl = await sock.profilePictureUrl(jid, 'image')
```

--------------------------------

### Use makeInMemoryStore with Baileys

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Sets up an in-memory store that persists to a JSON file every 10 seconds, binds it to a WhatsApp socket, and logs chat and contact updates. The store can be read from a file and written to a file, and it listens to socket events to keep data up-to-date.

```ts
import makeWASocket, { makeInMemoryStore } from '@whiskeysockets/baileys'
// the store maintains the data of the WA connection in memory
// can be written out to a file & read from it
const store = makeInMemoryStore({ })
// can be read from a file
store.readFromFile('./baileys_store.json')
// saves the state to a file every 10s
setInterval(() => {
    store.writeToFile('./baileys_store.json')
}, 10_000)

const sock = makeWASocket({ })
// will listen from this socket
// the store can listen from a new socket once the current socket outlives its lifetime
store.bind(sock.ev)

sock.ev.on('chats.upsert', () => {
    // can use 'store.chats' however you want, even after the socket dies out
    // 'chats' => a KeyedDB instance
    console.log('got chats', store.chats.all())
})

sock.ev.on('contacts.upsert', () => {
    console.log('got contacts', Object.values(store.contacts))
})
```

--------------------------------

### makeCacheableSignalKeyStore type signature

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/auth-state.md

Type signature for makeCacheableSignalKeyStore. It wraps a SignalKeyStore with an LRU-style cache (stdTTL: 5 minutes). get() serves cache hits, set() writes through, clear() flushes cache.

```typescript
export function makeCacheableSignalKeyStore(
	store: SignalKeyStore,
	logger?: ILogger,
	_cache?: CacheStore
): SignalKeyStore
```

--------------------------------

### Bot list and call link method signatures

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/chats-socket.md

TypeScript signatures for getBotListV2 and createCallLink. getBotListV2 returns a list of bot info objects. createCallLink creates a call link with optional start time and timeout.

```typescript
getBotListV2(): Promise<BotListInfo[]>                       // BotListInfo = { jid: string; personaId: string }
createCallLink(type: 'audio' | 'video', event?: { startTime: number }, timeoutMs?: number): Promise<string | undefined>
```

--------------------------------

### Group management operations with makeWASocket

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/groups-socket.md

Shows how to create a group, manage participants, approve join requests, handle invite flows, and update group settings. Includes error handling for participant updates and uses the `groupToggleEphemeral` method with 86400 for 24-hour ephemeral messages.

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

// create a group
const group = await sock.groupCreate('My Fab Group', [
	'15551234567@s.whatsapp.net',
	'15557654321@s.whatsapp.net'
])
await sock.sendMessage(group.id, { text: 'welcome!' })

// manage participants; groupParticipantsUpdate reports per-participant errors
const results = await sock.groupParticipantsUpdate(group.id, ['1555…@s.whatsapp.net'], 'promote')
for (const r of results) {
	if (r.status !== '200') console.error(`failed for ${r.jid}: ${r.status}`)
}

// approve join requests
await sock.groupRequestParticipantsUpdate(group.id, ['15551234567@s.whatsapp.net'], 'approve')

// invite flows
const code = await sock.groupInviteCode(group.id)
console.log(`https://chat.whatsapp.com/${code}`)
const meta = await sock.groupGetInviteInfo(code)
console.log(meta.subject)

// settings + ephemeral (0 = off, 86400 = 24h)
await sock.groupSettingUpdate(group.id, 'announcement')
await sock.groupToggleEphemeral(group.id, 86400)
```

--------------------------------

### Update Default Disappearing Mode with updateDefaultDisappearingMode

Source: https://github.com/whiskeysockets/baileys/blob/master/README.md

Updates the default disappearing mode. The ephemeral value is in seconds; for example, 86400 corresponds to 24 hours. Other options include 0 (remove), 604800 (7 days), and 7776000 (90 days).

```ts
const ephemeral = 86400
await sock.updateDefaultDisappearingMode(ephemeral)
```

--------------------------------

### assertSessions

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/messages-send.md

Runs an IQ key request for sessions that are missing or all when force is true, injecting the returned E2E sessions.

```APIDOC
## assertSessions

### Description
Runs an <iq xmlns=encrypt type=get> key request for sessions that are missing (or all, when force), injecting the returned E2E sessions via parseAndInjectE2ESessions.

### Method
assertSessions

### Signature
assertSessions(jids: string[], force?: boolean): Promise<boolean>

### Parameters
#### Parameters
- **jids** (string[]) - Required - Array of JIDs.
- **force** (boolean) - Optional - If true, fetch sessions for all JIDs even if they exist.

### Returns
Promise<boolean> - true if any session was fetched.
```

--------------------------------

### Community creation and approval flow

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/communities-socket.md

Shows the main community workflow: create a community, create a linked subgroup, link it, fetch linked groups, enable join approval, and approve a participant request. Requires an authenticated socket instance.

```ts
import makeWASocket from '@whiskeysockets/baileys'

const sock = makeWASocket({ auth })

// create a community and a linked subgroup
const community = await sock.communityCreate('My Community', 'main hub')
const subgroup = await sock.communityCreateGroup('Sub group', ['1555…@s.whatsapp.net'], community.id)
await sock.communityLinkGroup(subgroup.id, community.id)

// inspect link structure
const { communityJid, isCommunity, linkedGroups } = await sock.communityFetchLinkedGroups(subgroup.id)
console.log(isCommunity, linkedGroups)

// approval flow
await sock.communityJoinApprovalMode(community.id, 'on')
await sock.communityRequestParticipantsUpdate(community.id, ['1555…@s.whatsapp.net'], 'approve')
```

--------------------------------

### Send IQ with sock.query and timeout

Source: https://github.com/whiskeysockets/baileys/blob/master/AGENTS.md

Send IQ queries with sock.query and a timeout. query auto-generates the stanza id, attaches a one-shot listener, and rejects on timeout. Avoid manual sock.ws.send + listener to prevent leaks.

```ts
const result = await sock.query({
  tag: 'iq',
  attrs: { to: S_WHATSAPP_NET, type: 'get', xmlns: 'w:profile:picture' },
  content: [{ tag: 'picture', attrs: { type: 'image', query: 'url' } }]
}, /* timeoutMs */ 15_000)
```

--------------------------------

### Custom signal repository hook with makeLibSignalRepository

Source: https://github.com/whiskeysockets/baileys/blob/master/_autodocs/api-reference/signal-crypto.md

Use this snippet to customize the signal repository in Baileys by wrapping the default implementation. It logs a message before encrypting a message, then delegates to the original encryptMessage method. The example shows how to access the repository's methods and override them.

```ts
import makeWASocket, { makeLibSignalRepository } from '@whiskeysockets/baileys'

const sock = makeWASocket({
	auth: state,
	makeSignalRepository: (auth, logger, pnToLIDFunc) => {
		const repo = makeLibSignalRepository(auth, logger, pnToLIDFunc)
		return {
			...repo,
			async encryptMessage(opts) {
				console.log('encrypting for', opts.jid)
				return repo.encryptMessage(opts)
			}
		}
	}
})
```
Tokens:
Raw