@kelvdra/bails
Advanced tools
Advanced Baileys WhatsApp API Wrapper
A modern and feature-rich WhatsApp Web API built on top of Baileys — designed for automation, chatbots, and integration with any Node.js project.
Example usage:
cd path/to/Baileys
npm install
node example.js
Or check the example.ts for a TypeScript version.
Stable version
npm install @kelvdra/baileys
Edge version (latest features, may be unstable)
yarn add @kelvdra/baileys@latest
Import into your code
const { default: makeWASocket } = require("@kelvdra/baileys")
⚠️ Tip: Use the stable version for production environments.
WhatsApp supports multi-device API, allowing Baileys to act as a secondary WhatsApp Web client.
You can connect via QR Code or Pairing Code.
const { default: makeWASocket, Browsers } = require("@kelvdra/baileys");
const sock = makeWASocket({
browser: Browsers.ubuntu('My App'),
printQRInTerminal: true
});
💡 Scan the QR code with WhatsApp on your phone to log in.
const { default: makeWASocket } = require("@kelvdra/baileys");
const sock = makeWASocket({
printQRInTerminal: false
});
if (!sock.authState.creds.registered) {
const number = '6281234567890'; // no symbols, only numbers
const code = await sock.requestPairingCode(number);
console.log(code);
}
⚠️ Note: Pairing code works only with one device at a time.
const groupCache = new NodeCache({ stdTTL: 5 * 60, useClones: false });
const sock = makeWASocket({
cachedGroupMetadata: async (jid) => groupCache.get(jid)
});
const sock = makeWASocket({
getMessage: async (key) => await getMessageFromStore(key)
});
const sock = makeWASocket({
markOnlineOnConnect: false
});
Avoid scanning QR every time:
const makeWASocket = require("@kelvdra/baileys").default;
const { useMultiFileAuthState } = require("@kelvdra/baileys");
const { state, saveCreds } = await useMultiFileAuthState('auth_info_baileys');
const sock = makeWASocket({ auth: state });
sock.ev.on('creds.update', saveCreds);
💡 Recommended to store auth in a database for production.
Listen to events using:
sock.ev.on('messages.upsert', ({ messages }) => {
console.log('got messages', messages);
});
[!NOTE] This example includes basic auth storage too
const makeWASocket = require("@kelvdra/baileys").default;
const { DisconnectReason, useMultiFileAuthState } = require("@kelvdra/baileys");
const Boom = require('@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()
[!IMPORTANT] In
messages.upsertit's recommended to use a loop likefor (const message of event.messages)to handle all messages in array
messages.updatesock.ev.on('messages.update', event => {
for(const { key, update } of event) {
if(update.pollUpdates) {
const pollCreation = await getMessage(key)
if(pollCreation) {
console.log(
'got poll update, aggregation: ',
getAggregateVotesInPollMessage({
message: pollCreation,
pollUpdates: update.pollUpdates,
})
)
}
}
}
})
getMessage is a store implementation (in your end)connection.update will be fired requesting you to restart sockmessaging.history-set[!IMPORTANT] I highly recommend building your own data store, as storing someone's entire chat history in memory is a terrible waste of RAM.
It can be used as follows:
const makeWASocket = require("@kelvdra/baileys").default;
const { makeInMemoryStore } = require("@kelvdra/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))
})
The store also provides some simple functions such as loadMessages that utilize the store to speed up data retrieval.
id is the WhatsApp ID, called jid too, of the person or group you're sending the message to.
[country code][phone number]@s.whatsapp.net
- Example for people: +19999999999@s.whatsapp.net.
- For groups, it must be in the format 123456789-123345@g.us.[timestamp of creation]@broadcast.status@broadcast.getContentType, returns the content type for any messagegetDevice, returns the device from messagemakeCacheableSignalKeyStore, make auth store more fastdownloadContentFromMessage, download content from any messageSend all types of messages with a single function
const jid: string
const content: AnyMessageContent
const options: MiscMessageGenerationOptions
sock.sendMessage(jid, content, options)
await sock.sendMessage(jid, { text: 'hello word' })
await sock.sendMessage(jid, { text: 'hello word' }, { quoted: message })
await sock.sendMessage(
jid,
{
text: '@12345678901',
mentions: ['12345678901@s.whatsapp.net']
}
)
await sock.sendStatusMentions(
{
text: "Hello", // or image / video / audio ( url or buffer )
},
[
"123456789123456789@g.us",
"123456789@s.whatsapp.net",
// Enter jid chat here
]
)
await sock.sendMessage(
jid,
{
pollResult: {
name: "Text poll",
votes: [["Options 1", 10], ["Options 2", 10]], // 10 For Fake Polling Count Results
}
}, { quoted : message }
)
await sock.sendAlbumMessage(
jid,
[
{
image: { url: "https://example.jpg" }, // or buffer
caption: "Hello World",
},
{
video: { url: "https://example.mp4" }, // or buffer
caption: "Hello World",
},
],
{
quoted : message,
delay : 2000 // number in seconds
}
)
- Example non media sticker
await sock.sendMessage(
jid,
{
requestPayment: {
currency: "IDR",
amount: "10000000",
from: "123456@s.whatsapp.net",
note: "Hai Guys",
background: { ...background of the message }
}
},
{ quoted : message }
)
- with media sticker buffer
await sock.sendMessage(
jid,
{
requestPayment: {
currency: "IDR",
amount: "10000000",
from: "123456@s.whatsapp.net",
sticker: Buffer,
background: { ...background of the message }
}
},
{ quoted : message }
)
- with media sticker url
await sock.sendMessage(
jid,
{
requestPayment: {
currency: "IDR",
amount: "10000000",
from: "123456@s.whatsapp.net",
sticker: { url: Sticker Url },
background: { ...background of the message }
}
},
{ quoted : message }
)
await sock.sendMessage(
jid,
{
event: {
isCanceled: false, // or true for cancel event
name: "Name Event",
description: "Description Event",
location: {
degressLatitude: -0,
degressLongitude: - 0
},
link: Call Link,
startTime: m.messageTimestamp.low,
endTime: m.messageTimestamp.low + 86400, // 86400 is day in seconds
extraGuestsAllowed: true // or false
}
},
{ quoted : message }
)
conn.sendMessage(m.chat, {
productMessage: {
title: "tes",
description: "penis",
thumbnail: "https://example.png",
productId: "123456789",
retailerId: "TOKOKU",
url: "https://example.png",
body: "penis",
footer: "wabot",
buttons: [
{
name: "cta_url",
buttonParamsJson: JSON.stringify({
display_text: "K",
url: "google.com"
})
}
]
}
}, { quoted: m });
func nya kyk gini, nanti ku taro ke readme
await conn.sendMessage(
m.chat,
{
carouselMessage: {
caption: "Klik Url",
footer: "Powered By Hydra",
cards: [
// ✅ Card Mode Product
{
headerTitle: "`</> Owner Bot </>`",
imageUrl: logo.thumb,
productTitle: "Premium Bot",
productDescription: "Dapatkan akses premium",
bodyText: "[Hydra]\n- Chat yang penting aja\n- Jangan telpon owner",
buttons: [
{
name: "cta_call",
params: { display_text: "Contact Owner", phone_number: "+6287784901856" }
}
]
},
// ✅ Card Mode Gambar Biasa
{
headerTitle: "`</> Bot Elaina </>`",
imageUrl: logo.thumb,
bodyText: "[Elaina AI]\n- Jangan spam bot\n- Jangan telpon bot",
buttons: [
{
name: "cta_url",
params: {
display_text: "Chat Bot",
url: "https://wa.me/6281918402014",
merchant_url: "https://wa.me/6281918402014"
}
}
]
}
]
}
},
{ quoted: m },
conn
);
- Example non header media
await sock.sendMessage(
jid,
{
text: "Description Of Messages", //Additional information
title: "Title Of Messages",
subtitle: "Subtitle Message",
footer: "Footer Messages",
interactiveButtons: [
{
name: "quick_reply",
buttonParamsJson: JSON.stringify({
display_text: "Display Button",
id: "ID"
})
},
{
name: "cta_url",
buttonParamsJson: JSON.stringify({
display_text: "Display Button",
url: "https://www.example.com"
})
}
]
},
{ quoted : message }
)
- Example with media
await sock.sendMessage(
jid,
{
image: { url : "https://example.jpg" }, // Can buffer
caption: "Description Of Messages", //Additional information
title: "Title Of Messages",
subtitle: "Subtile Message",
footer: "Footer Messages",
media: true,
interactiveButtons: [
{
name: "quick_reply",
buttonParamsJson: JSON.stringify({
display_text: "Display Button",
id: "ID"
})
},
{
name: "cta_url",
buttonParamsJson: JSON.stringify({
display_text: "Display Button",
url: "https://www.example.com"
})
}
]
},
{ quoted : message }
)
- Example with header product
await sock.sendMessage(
jid,
{
product: {
productImage: { url: "https://example.jpg }, //or buffer
productImageCount: 1,
title: "Title Product",
description: "Description Product",
priceAmount1000: 20000 * 1000,
currencyCode: "IDR",
retailerId: "Retail",
url: "https://example.com",
},
businessOwnerJid: "1234@s.whatsapp.net",
caption: "Description Of Messages", //Additional information
title: "Title Of Messages",
footer: "Footer Messages",
media: true,
interactiveButtons: [
{
name: "quick_reply",
buttonParamsJson: JSON.stringify({
display_text: "Display Button",
id: "ID"
})
},
{
name: "cta_url",
buttonParamsJson: JSON.stringify({
display_text: "Display Button",
url: "https://www.example.com"
})
}
]
},
{ quoted : message }
)
const msg = getMessageFromStore() // implement this on your end
await sock.sendMessage(jid, { forward: msg }) // WA forward the message!
await sock.sendMessage(
jid,
{
location: {
degreesLatitude: 24.121231,
degreesLongitude: 55.1121221
}
}
)
const vcard = 'BEGIN:VCARD\n' // metadata of the contact card
+ 'VERSION:3.0\n'
+ 'FN:Jeff Singh\n' // full name
+ 'ORG:Ashoka Uni;\n' // the organization of the contact
+ 'TEL;type=CELL;type=VOICE;waid=911234567890:+91 12345 67890\n' // WhatsApp ID + phone number
+ 'END:VCARD'
await sock.sendMessage(
id,
{
contacts: {
displayName: 'Jeff',
contacts: [{ vcard }]
}
}
)
await sock.sendMessage(
jid,
{
react: {
text: '💖', // use an empty string to remove the reaction
key: message.key
}
}
)
| Time | Seconds |
|---|---|
| 24h | 86.400 |
| 7d | 604.800 |
| 30d | 2.592.000 |
await sock.sendMessage(
jid,
{
pin: {
type: 1, // 0 to remove
time: 86400
key: message.key
}
}
)
| Time | Seconds |
|---|---|
| 24h | 86.400 |
| 7d | 604.800 |
| 30d | 2.592.000 |
await sock.sendMessage(
jid,
{
keep: message.key,
type: 1, // 2 to unpin
time: 86400
}
)
await sock.sendMessage(
jid,
{
poll: {
name: 'My Poll',
values: ['Option 1', 'Option 2', ...],
selectableCount: 1,
toAnnouncementGroup: false // or true
}
}
)
link-preview-js as a dependency to your project with yarn add link-preview-jsawait sock.sendMessage(
jid,
{
text: 'Hi, this was sent using https://github.com/whiskeysockets/baileys'
}
)
Sending media (video, stickers, images) is easier & more efficient than ever.
[!NOTE] In media messages, you can pass
{ stream: Stream }or{ url: Url }orBufferdirectly, you can see more here
[!TIP] It's recommended to use Stream or Url to save memory
.gif files, that's why we send gifs as common .mp4 video with gifPlayback flagawait sock.sendMessage(
jid,
{
video: fs.readFileSync('Media/ma_gif.mp4'),
caption: 'hello word',
gifPlayback: true
}
)
await sock.sendMessage(
id,
{
video: {
url: './Media/ma_gif.mp4'
},
caption: 'hello word',
ptv: false // if set to true, will send as a `video note`
}
)
ffmpeg with this flags:
codec: libopus //ogg file
ac: 1 //one channel
avoid_negative_ts
make_zero
ffmpeg -i input.mp4 -avoid_negative_ts make_zero -ac 1 output.ogg
await sock.sendMessage(
jid,
{
audio: {
url: './Media/audio.mp3'
},
mimetype: 'audio/mp4'
}
)
await sock.sendMessage(
id,
{
image: {
url: './Media/ma_img.png'
},
caption: 'hello word'
}
)
viewOnce, you only need to pass viewOnce: true in content objectawait sock.sendMessage(
id,
{
image: {
url: './Media/ma_img.png'
},
viewOnce: true, //works with video, audio too
caption: 'hello word'
}
)
const msg = await sock.sendMessage(jid, { text: 'hello word' })
await sock.sendMessage(jid, { delete: msg.key })
Note: deleting for oneself is supported via chatModify, see in this section
await sock.sendMessage(jid, {
text: 'updated text goes here',
edit: response.key,
});
jimp or sharp as a dependency in your project using yarn add jimp or yarn add sharp.ffmpeg installed on your system.If you want to save the media you received
const { createWriteStream } = require('fs');
const { downloadMediaMessage, getContentType } = require("@kelvdra/baileys");
sock.ev.on('messages.upsert', async ({ [m] }) => {
if (!m.message) return // if there is no text or media message
const messageType = getContentType(m) // get what type of message it is (text, image, video...)
// if the message is an image
if (messageType === 'imageMessage') {
// download the message
const stream = await downloadMediaMessage(
m,
'stream', // can be 'buffer' too
{ },
{
logger,
// pass this so that baileys can request a reupload of media
// that has been deleted
reuploadRequest: sock.updateMediaMessage
}
)
// save to file
const writeStream = createWriteStream('./my-download.jpeg')
stream.pipe(writeStream)
}
}
await sock.updateMediaMessage(msg)
callId and callFrom from call eventawait sock.rejectCall(callId, callFrom)
const key: WAMessageKey
// can pass multiple keys to read multiple messages as well
await sock.readMessages([key])
The message ID is the unique identifier of the message that you are marking as read.
On a WAMessage, the messageID can be accessed using messageID = message.key.id.
presence can be one of thesejid know whether you're online, offline, typing etc.await sock.sendPresenceUpdate('available', jid)
[!NOTE] If a desktop client is active, WA doesn't send push notifications to the device. If you would like to receive said notifications -- mark your Baileys client offline using
sock.sendPresenceUpdate('unavailable')
WA uses an encrypted form of communication to send chat/app updates. This has been implemented mostly and you can send the following updates:
[!IMPORTANT] If you mess up one of your updates, WA can log you out of all your devices and you'll have to log in again.
const lastMsgInChat = await getLastMessageInChat(jid) // implement this on your end
await sock.chatModify({ archive: true, lastMessages: [lastMsgInChat] }, jid)
| Time | Miliseconds |
|---|---|
| Remove | null |
| 8h | 86.400.000 |
| 7d | 604.800.000 |
// mute for 8 hours
await sock.chatModify({ mute: 8 * 60 * 60 * 1000 }, jid)
// unmute
await sock.chatModify({ mute: null }, jid)
const lastMsgInChat = await getLastMessageInChat(jid) // implement this on your end
// mark it unread
await sock.chatModify({ markRead: false, lastMessages: [lastMsgInChat] }, jid)
await sock.chatModify(
{
clear: {
messages: [
{
id: 'ATWYHDNNWU81732J',
fromMe: true,
timestamp: '1654823909'
}
]
}
},
jid
)
const lastMsgInChat = await getLastMessageInChat(jid) // implement this on your end
await sock.chatModify({
delete: true,
lastMessages: [
{
key: lastMsgInChat.key,
messageTimestamp: lastMsgInChat.messageTimestamp
}
]
},
jid
)
await sock.chatModify({
pin: true // or `false` to unpin
},
jid
)
await sock.chatModify({
star: {
messages: [
{
id: 'messageID',
fromMe: true // or `false`
}
],
star: true // - true: Star Message; false: Unstar Message
}
},
jid
)
| Time | Seconds |
|---|---|
| Remove | 0 |
| 24h | 86.400 |
| 7d | 604.800 |
| 90d | 7.776.000 |
// turn on disappearing messages
await sock.sendMessage(
jid,
// this is 1 week in seconds -- how long you want messages to appear for
{ disappearingMessagesInChat: WA_DEFAULT_EPHEMERAL }
)
// will send as a disappearing message
await sock.sendMessage(jid, { text: 'hello' }, { ephemeralExpiration: WA_DEFAULT_EPHEMERAL })
// turn off disappearing messages
await sock.sendMessage(
jid,
{ disappearingMessagesInChat: false }
)
const [result] = await sock.onWhatsApp(jid)
if (result.exists) console.log (`${jid} exists on WhatsApp, as jid: ${result.jid}`)
const msg = await getOldestMessageInChat(jid)
await sock.fetchMessageHistory(
50, //quantity (max: 50 per query)
msg.key,
msg.messageTimestamp
)
messaging.history-set eventconst jid = "123456789@s.whatsapp.net"
const lid = await sock.fetchUserLid(jid)
console.log('user lid: ' + lid)
const status = await sock.fetchStatus(jid)
console.log('status: ' + status)
// for low res picture
const ppUrl = await sock.profilePictureUrl(jid)
console.log(ppUrl)
// for high res picture
const ppUrl = await sock.profilePictureUrl(jid, 'image')
const profile = await sock.getBusinessProfile(jid)
console.log('business description: ' + profile.description + ', category: ' + profile.category)
// the presence update is fetched and called here
sock.ev.on('presence.update', console.log)
// request updates for a chat
await sock.presenceSubscribe(jid)
await sock.updateProfileStatus('Hello World!')
await sock.updateProfileName('My name')
[!NOTE] Like media messages, you can pass
{ stream: Stream }or{ url: Url }orBufferdirectly, you can see more here
await sock.updateProfilePicture(jid, { url: './new-profile-picture.jpeg' })
await sock.removeProfilePicture(jid)
// title & participants
const group = await sock.groupCreate('My Fab Group', ['1234@s.whatsapp.net', '4564@s.whatsapp.net'])
console.log('created group with id: ' + group.gid)
await sock.sendMessage(group.id, { text: 'hello there' }) // say hello to everyone on the group
// id & people to add to the group (will throw error if it fails)
await sock.groupParticipantsUpdate(
jid,
['abcd@s.whatsapp.net', 'efgh@s.whatsapp.net'],
'add' // replace this parameter with 'remove' or 'demote' or 'promote'
)
await sock.groupUpdateSubject(jid, 'New Subject!')
await sock.groupUpdateDescription(jid, 'New Description!')
// only allow admins to send messages
await sock.groupSettingUpdate(jid, 'announcement')
// allow everyone to send messages
await sock.groupSettingUpdate(jid, 'not_announcement')
// allow everyone to modify the group's settings -- like display picture etc.
await sock.groupSettingUpdate(jid, 'unlocked')
// only allow admins to modify the group's settings
await sock.groupSettingUpdate(jid, 'locked')
// will throw error if it fails
await sock.groupLeave(jid)
'https://chat.whatsapp.com/' + codeconst code = await sock.groupInviteCode(jid)
console.log('group code: ' + code)
const code = await sock.groupRevokeInvite(jid)
console.log('New group code: ' + code)
https://chat.whatsapp.com/, only codeconst response = await sock.groupAcceptInvite(code)
console.log('joined to: ' + response)
const response = await sock.groupGetInviteInfo(code)
console.log('group information: ' + response)
const metadata = await sock.groupMetadata(jid)
console.log(metadata.id + ', title: ' + metadata.subject + ', description: ' + metadata.desc)
groupInviteMessageconst response = await sock.groupAcceptInviteV4(jid, groupInviteMessage)
console.log('joined to: ' + response)
const response = await sock.groupRequestParticipantsList(jid)
console.log(response)
const response = await sock.groupRequestParticipantsUpdate(
jid, // group id
['abcd@s.whatsapp.net', 'efgh@s.whatsapp.net'],
'approve' // or 'reject'
)
console.log(response)
const response = await sock.groupFetchAllParticipating()
console.log(response)
| Time | Seconds |
|---|---|
| Remove | 0 |
| 24h | 86.400 |
| 7d | 604.800 |
| 90d | 7.776.000 |
await sock.groupToggleEphemeral(jid, 86400)
await sock.groupMemberAddMode(
jid,
'all_member_add' // or 'admin_add'
)
await sock.updateBlockStatus(jid, 'block') // Block user
await sock.updateBlockStatus(jid, 'unblock') // Unblock user
const privacySettings = await sock.fetchPrivacySettings(true)
console.log('privacy settings: ' + privacySettings)
const response = await sock.fetchBlocklist()
console.log(response)
const value = 'all' // 'contacts' | 'contact_blacklist' | 'none'
await sock.updateLastSeenPrivacy(value)
const value = 'all' // 'match_last_seen'
await sock.updateOnlinePrivacy(value)
const value = 'all' // 'contacts' | 'contact_blacklist' | 'none'
await sock.updateProfilePicturePrivacy(value)
const value = 'all' // 'contacts' | 'contact_blacklist' | 'none'
await sock.updateStatusPrivacy(value)
const value = 'all' // 'none'
await sock.updateReadReceiptsPrivacy(value)
const value = 'all' // 'contacts' | 'contact_blacklist'
await sock.updateGroupsAddPrivacy(value)
| Time | Seconds |
|---|---|
| Remove | 0 |
| 24h | 86.400 |
| 7d | 604.800 |
| 90d | 7.776.000 |
const ephemeral = 86400
await sock.updateDefaultDisappearingMode(ephemeral)
await sock.sendMessage(
jid,
{
image: {
url: url
},
caption: caption
},
{
backgroundColor: backgroundColor,
font: font,
statusJidList: statusJidList,
broadcast: true
}
)
Message body can be a extendedTextMessage or imageMessage or videoMessage or voiceMessage, see here
You can add backgroundColor and other options in the message options, see here
broadcast: true enables broadcast mode
statusJidList: a list of people that you can get which you need to provide, which are the people who will get this status message.
You can send messages to broadcast lists the same way you send messages to groups & individual chats.
Right now, WA Web does not support creating broadcast lists, but you can still delete them.
Broadcast IDs are in the format 12345678@broadcast
const bList = await sock.getBroadcastListInfo('1234@broadcast')
console.log (`list name: ${bList.name}, recps: ${bList.recipients}`)
Baileys is written with custom functionality in mind. Instead of forking the project & re-writing the internals, you can simply write your own extensions.
First, enable the logging of unhandled messages from WhatsApp by setting:
const sock = makeWASocket({
logger: P({ level: 'debug' }),
})
This will enable you to see all sorts of messages WhatsApp sends in the console.
[!TIP] If you want to learn whatsapp protocol, we recommend to study about Libsignal Protocol and Noise Protocol
{
"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"
}
The 'frame' is what the message received is, it has three components:
tag -- what this frame is about (eg. message will have 'message')attrs -- a string key-value pair with some metadata (contains ID of the message usually)content -- the actual data (eg. a message node will have the actual message content in it)[!TIP] Recommended to see
onMessageReceivedfunction insocket.tsfile to understand how websockets events are fired
// for any message with tag 'edge_routing'
sock.ws.on('CB:edge_routing', (node: BinaryNode) => { })
// for any message with tag 'edge_routing' and id attribute = abcd
sock.ws.on('CB:edge_routing,id:abcd', (node: BinaryNode) => { })
// for any message with tag 'edge_routing', id attribute = abcd & first content node routing_info
sock.ws.on('CB:edge_routing,id:abcd,routing_info', (node: BinaryNode) => { })
[!NOTE] Also, this repo is now licenced under GPL 3 since it uses libsignal-node
FAQs
Baileys Bot Whatsapp by Kelvdra
The npm package @kelvdra/bails receives a total of 35 weekly downloads. As such, @kelvdra/bails popularity was classified as not popular.
We found that @kelvdra/bails demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Ruby maintainers from Bundler and rbenv teams are building rv to bring Python uv's speed and unified tooling approach to Ruby development.
Security News
Following last week’s supply chain attack, Nx published findings on the GitHub Actions exploit and moved npm publishing to Trusted Publishers.
Security News
AGENTS.md is a fast-growing open format giving AI coding agents a shared, predictable way to understand project setup, style, and workflows.