`javascript
import makeWASocket, { DisconnectReason, useMultiFileAuthState } from 'xnxx-bail-pro'

async function connectToWhatsApp() {
const { state, saveCreds } = await useMultiFileAuthState('auth_session')

const sock = makeWASocket({
auth: state,
printQRInTerminal: true,
browser: ['XNXX Baileys', 'Chrome', '1.0.0']
})

sock.ev.on('connection.update', (update) => {
const { connection, lastDisconnect } = update
if(connection === 'close') {
const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut
if(shouldReconnect) {
connectToWhatsApp()
}
} else if(connection === 'open') {
console.log('✅ Connected to WhatsApp!')
}
})

sock.ev.on('messages.upsert', async ({ messages }) => {
for(const msg of messages) {
if(!msg.key.fromMe && msg.message) {
await sock.sendMessage(msg.key.remoteJid, {
text: 'Hello from XNXX Baileys!'
})
}
}
})

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

connectToWhatsApp()
`

`javascript
import makeWASocket from 'xnxx-bail-pro'

const sock = makeWASocket({
auth: state,
printQRInTerminal: true,
browser: ['XNXX Bot', 'Chrome', '1.0.0']
})
`

`javascript
const sock = makeWASocket({
auth: state,
printQRInTerminal: false
})

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

`javascript
const phoneNumber = "628XXXXX"
const code = await sock.requestPairingCode(phoneNumber.trim(), "CUSTOM01")
console.log("Your pairing code: " + code)
`

`javascript
const NodeCache = require('node-cache')
const groupCache = new NodeCache({ stdTTL: 5 * 60, useClones: false })

const sock = makeWASocket({
cachedGroupMetadata: async (jid) => groupCache.get(jid)
})

sock.ev.on('groups.update', async ([event]) => {
const metadata = await sock.groupMetadata(event.id)
groupCache.set(event.id, metadata)
})
`

`javascript
const sock = makeWASocket({
getMessage: async (key) => await getMessageFromStore(key)
})
`

`javascript
const sock = makeWASocket({
markOnlineOnConnect: false
})
`

`javascript
import makeWASocket, { useMultiFileAuthState } from 'xnxx-bail-pro'

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

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

> Note: For production, store auth in a database instead of files.

`javascript
sock.ev.on('connection.update', (update) => {
const { connection, lastDisconnect } = update
if(connection === 'close') {
const shouldReconnect = lastDisconnect?.error?.output?.statusCode !== DisconnectReason.loggedOut
console.log('Connection closed, reconnecting:', shouldReconnect)
if(shouldReconnect) connectToWhatsApp()
} else if(connection === 'open') {
console.log('Connection opened')
}
})
`

`javascript
sock.ev.on('messages.upsert', async ({ messages }) => {
for(const msg of messages) {
console.log('New message:', msg)
}
})
`

`javascript
sock.ev.on('messages.update', async (updates) => {
for(const update of updates) {
console.log('Message updated:', update)
}
})
`

`javascript
sock.ev.on('messages.update', async (event) => {
for(const { key, update } of event) {
if(update.pollUpdates) {
const pollCreation = await getMessage(key)
if(pollCreation) {
console.log('Poll update:', getAggregateVotesInPollMessage({
message: pollCreation,
pollUpdates: update.pollUpdates,
}))
}
}
}
})
`

`javascript
import makeWASocket, { makeInMemoryStore } from 'xnxx-bail-pro'

const store = makeInMemoryStore({})
store.readFromFile('./baileys_store.json')

setInterval(() => {
store.writeToFile('./baileys_store.json')
}, 10_000)

const sock = makeWASocket({})
store.bind(sock.ev)

sock.ev.on('chats.upsert', () => {
console.log('Got chats:', store.chats.all())
})

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

> Important: Build your own data store for production. In-memory storage wastes RAM.

`javascript
await sock.sendMessage(jid, { text: 'Hello World!' })
`

`javascript
await sock.sendMessage(jid, { text: 'This is a reply' }, { quoted: message })
`

`javascript
await sock.sendMessage(jid, {
text: '@12345678901',
mentions: ['12345678901@s.whatsapp.net']
})
`

`javascript
await sock.sendAlbumMessage(
jid,
[
{
image: { url: "https://example.jpg" },
caption: "Hello World",
},
{
video: { url: "https://example.mp4" },
caption: "Hello World",
},
],
{
quoted: message,
delay: 2000
}
)
`

`javascript
await sock.sendMessage(jid, {
requestPayment: {
currency: "USD",
amount: "10000000",
from: "123456@s.whatsapp.net",
note: "Payment Request",
background: { }
}
}, { quoted: message })
`

`javascript
await sock.sendMessage(jid, {
event: {
isCanceled: false,
name: "Event Name",
description: "Event Description",
location: {
degreesLatitude: -0,
degreesLongitude: -0
},
startTime: m.messageTimestamp.low,
endTime: m.messageTimestamp.low + 86400,
}
}, { quoted: message })
`

`javascript
await sock.sendMessage(jid, {
productMessage: {
title: "Product Title",
description: "Product Description",
thumbnail: "https://example.png",
productId: "123456789",
retailerId: "STORE",
url: "https://example.png",
}
}, { quoted: message })
`

`javascript
await sock.sendMessage(jid, {
carouselMessage: {
caption: "Click URL",
footer: "Powered By XNXX Baileys",
cards: [
{
headerTitle: "Card 1",
imageUrl: "https://example.com/image.jpg",
productTitle: "Premium Product",
productDescription: "Get premium access",
bodyText: "Description here",
buttons: [
{
name: "cta_call",
params: {
display_text: "Contact",
phone_number: "+1234567890"
}
}
]
}
]
}
}, { quoted: message })
`

`javascript
await sock.sendMessage(jid, {
text: "Description of Message",
title: "Title of Message",
footer: "Footer Message",
interactiveButtons: [
{
name: "quick_reply",
buttonParamsJson: JSON.stringify({
display_text: "Quick Reply",
id: "button_1"
})
},
{
name: "cta_url",
buttonParamsJson: JSON.stringify({
display_text: "Visit Website",
url: "https://example.com"
})
}
]
}, { quoted: message })
`

`javascript
await sock.sendMessage(jid, {
location: {
degreesLatitude: 24.121231,
degreesLongitude: 55.1121221,
name: "Location Name",
address: "Location Address"
}
})
`

`javascript
const vcard = 'BEGIN:VCARD\n'
+ 'VERSION:3.0\n'
+ 'FN:John Doe\n'
+ 'ORG:Company;\n'
+ 'TEL;type=CELL;type=VOICE;waid=1234567890:+1 234 567 890\n'
+ 'END:VCARD'

await sock.sendMessage(jid, {
contacts: {
displayName: 'John Doe',
contacts: [{ vcard }]
}
})
`

`javascript
await sock.sendMessage(jid, {
react: {
text: '❤️',
key: message.key
}
})
`

`javascript
await sock.sendMessage(jid, {
poll: {
name: 'Favorite Color?',
values: ['Red', 'Blue', 'Green', 'Yellow'],
selectableCount: 1
}
})
`

`javascript
// From URL
await sock.sendMessage(jid, {
image: { url: 'https://example.com/image.jpg' },
caption: 'Beautiful image!'
})

// From Buffer
await sock.sendMessage(jid, {
image: buffer,
caption: 'Image from buffer'
})
`

`javascript
await sock.sendMessage(jid, {
video: { url: './video.mp4' },
caption: 'Check this out!',
gifPlayback: false,
ptv: false
})
`

`javascript
await sock.sendMessage(jid, {
audio: { url: './audio.mp3' },
mimetype: 'audio/mp4',
ptt: true
})
`

`javascript
await sock.sendMessage(jid, {
document: { url: './document.pdf' },
fileName: 'document.pdf',
mimetype: 'application/pdf'
})
`

`javascript
await sock.sendMessage(jid, {
sticker: { url: './sticker.webp' }
})
`

`javascript
await sock.stickerPackMessage(jid, {
name: 'My Stickers',
publisher: 'Your Bot',
description: 'Collection of stickers',
stickers: [
{ data: buffer, emojis: ['😊'] },
{ data: './sticker.png', emojis: ['😂'] },
{ data: 'https://example.com/sticker.jpg', emojis: ['❤️'] }
],
cover: buffer
}, { quoted: message });
`

`javascript
const msg = await sock.sendMessage(jid, { text: 'hello' })
await sock.sendMessage(jid, { delete: msg.key })
`

`javascript
await sock.sendMessage(jid, {
text: 'Updated message text',
edit: originalMessage.key
})
`

`javascript
import { downloadMediaMessage, getContentType } from 'xnxx-bail-pro'

sock.ev.on('messages.upsert', async ({ messages }) => {
const msg = messages[0]
if(!msg.message) return

const messageType = getContentType(msg.message)

if(messageType === 'imageMessage') {
const buffer = await downloadMediaMessage(
msg,
'buffer',
{},
{
logger: console,
reuploadRequest: sock.updateMediaMessage
}
)
fs.writeFileSync('./download.jpeg', buffer)
}
})
`

`javascript
const group = await sock.groupCreate('Group Name', [
'1234567890@s.whatsapp.net',
'0987654321@s.whatsapp.net'
])
console.log('Group created:', group.id)
`

`javascript
// Add
await sock.groupParticipantsUpdate(groupJid, ['1234567890@s.whatsapp.net'], 'add')

// Remove
await sock.groupParticipantsUpdate(groupJid, ['1234567890@s.whatsapp.net'], 'remove')

// Promote to admin
await sock.groupParticipantsUpdate(groupJid, ['1234567890@s.whatsapp.net'], 'promote')

// Demote from admin
await sock.groupParticipantsUpdate(groupJid, ['1234567890@s.whatsapp.net'], 'demote')
`

`javascript
// Only admins can send messages
await sock.groupSettingUpdate(groupJid, 'announcement')

// Everyone can send messages
await sock.groupSettingUpdate(groupJid, 'not_announcement')

// Only admins can edit group info
await sock.groupSettingUpdate(groupJid, 'locked')

// Everyone can edit group info
await sock.groupSettingUpdate(groupJid, 'unlocked')
`

`javascript
const [result] = await sock.onWhatsApp('1234567890')
if(result?.exists) {
console.log('Number exists:', result.jid)
}
`

`javascript
const ppUrl = await sock.profilePictureUrl(jid)
const ppUrlHD = await sock.profilePictureUrl(jid, 'image')
`

`javascript
await sock.updateProfilePicture(jid, {
url: './profile.jpg'
})
`

`javascript
const status = await sock.fetchStatus(jid)
console.log('Status:', status)
`

`javascript
await sock.presenceSubscribe(jid)
await sock.sendPresenceUpdate('available', jid)
// Options: available, unavailable, composing, recording, paused
`

`javascript
// Block
await sock.updateBlockStatus(jid, 'block')

// Unblock
await sock.updateBlockStatus(jid, 'unblock')
`

`javascript
// Last seen: 'all', 'contacts', 'contact_blacklist', 'none'
await sock.updateLastSeenPrivacy('contacts')

// Online: 'all', 'match_last_seen'
await sock.updateOnlinePrivacy('all')

// Profile picture: 'all', 'contacts', 'contact_blacklist', 'none'
await sock.updateProfilePicturePrivacy('contacts')

// Groups add: 'all', 'contacts', 'contact_blacklist'
await sock.updateGroupsAddPrivacy('contacts')
`

`javascript
const lastMsg = await getLastMessageInChat(jid)
await sock.chatModify({
archive: true,
lastMessages: [lastMsg]
}, jid)
`

`javascript
// Mute for 8 hours
await sock.chatModify({
mute: 8 60 60 * 1000
}, jid)

// Unmute
await sock.chatModify({
mute: null
}, jid)
`

`javascript
// Pin
await sock.chatModify({ pin: true }, jid)

// Unpin
await sock.chatModify({ pin: false }, jid)
`

`javascript
await sock.sendMessage(jid, {
text: 'Broadcast message',
statusJidList: [
'1234567890@s.whatsapp.net',
'0987654321@s.whatsapp.net'
],
broadcast: true
})
`

`javascript
await sock.sendMessage('status@broadcast', {
image: { url: './story.jpg' },
caption: 'My story update!'
})
`

`javascript
// Create newsletter
await sock.newsletterCreate('Newsletter Name', {
description: 'Newsletter description',
picture: buffer
})

// Update newsletter
await sock.newsletterUpdateMetadata(newsletterJid, {
name: 'New Name',
description: 'New description'
})

// Follow/Unfollow
await sock.newsletterFollow(newsletterJid)
await sock.newsletterUnfollow(newsletterJid)
`

`javascript
// Enable (86400 = 24h, 604800 = 7d, 7776000 = 90d)
await sock.sendMessage(jid, {
disappearingMessagesInChat: 86400
})

// Disable
await sock.sendMessage(jid, {
disappearingMessagesInChat: false
})
`

`javascript
const msg = await sock.loadMessage(jid, messageId)
console.log('Message:', msg)
`

`javascript
const info = await sock.messageInfo(jid, messageId)
console.log('Read by:', info.readBy.length)
console.log('Played by:', info.playedBy.length)
`

`javascript
import { useMultiFileAuthState } from 'xnxx-bail-pro'

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

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

`javascript
import { makeInMemoryStore } from 'xnxx-bail-pro'

const store = makeInMemoryStore({})
store.readFromFile('./store.json')

setInterval(() => {
store.writeToFile('./store.json')
}, 10_000)

store.bind(sock.ev)
`

`javascript
try {
await sock.sendMessage(jid, { text: 'Hello' })
} catch(error) {
if(error.output?.statusCode === 401) {
console.log('Not authorized')
} else {
console.error('Send failed:', error)
}
}
`

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

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

if(shouldReconnect) {
console.log('Reconnecting...')
await connectToWhatsApp()
}
}
})
`