Here is an example you can use: example.ts or here is a tutorial for running the Baileys WhatsApp API code
cd path/to/Baileysnpm installnode example.js
Use the stable version:
npm install @vreden/metaUse the edge version (no guarantee of stability, but latest fixes + features)
yarn add @vreden/meta@latestThen import your code using:
const { default: makeWASocket } = require("@vreden/meta")-
- Create a Group
- Add/Remove or Demote/Promote
- Change Subject (name)
- Change Description
- Change Settings
- Leave a Group
- Get Invite Code
- Revoke Invite Code
- Join Using Invitation Code
- Get Group Info by Invite Code
- Query Metadata (participants, name, description...)
- Join using groupInviteMessage
- Get Request Join List
- Approve/Reject Request Join
- Get All Participating Groups Metadata
- Toggle Ephemeral
- Change Add Mode
WhatsApp provides a multi-device API that allows Baileys to be authenticated as a second WhatsApp client by scanning a QR code or Pairing Code with WhatsApp on your phone.
[!TIP] You can customize browser name if you connect with QR-CODE, with
Browserconstant, we have some browsers config, see here
const { default: makeWASocket } = require("@vreden/meta")
const sock = makeWASocket({
// can provide additional config here
browser: Browsers.ubuntu('My App'),
printQRInTerminal: true
})If the connection is successful, you will see a QR code printed on your terminal screen, scan it with WhatsApp on your phone and you'll be logged in!
[!IMPORTANT] Pairing Code isn't Mobile API, it's a method to connect Whatsapp Web without QR-CODE, you can connect only with one device, see here
The phone number can't have + or () or -, only numbers, you must provide country code
const { default: makeWASocket } = require("@vreden/meta")
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)
}- Set
syncFullHistoryastrue - Baileys, by default, use chrome browser config
- If you'd like to emulate a desktop connection (and receive more message history), this browser setting to your Socket config:
const sock = makeWASocket({
...otherOpts,
// can use Windows, Ubuntu here too
browser: Browsers.macOS('Desktop'),
syncFullHistory: true
})-
If you use baileys for groups, we recommend you to set
cachedGroupMetadatain socket config, you need to implement a cache like this: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) }) sock.ev.on('group-participants.update', async (event) => { const metadata = await sock.groupMetadata(event.id) groupCache.set(event.id, metadata) })
- If you want to improve sending message, retrying when error occurs and decrypt poll votes, you need to have a store and set
getMessageconfig in socket like this:const sock = makeWASocket({ getMessage: async (key) => await getMessageFromStore(key) })
- If you want to receive notifications in whatsapp app, set
markOnlineOnConnecttofalseconst sock = makeWASocket({ markOnlineOnConnect: false })
You obviously don't want to keep scanning the QR code every time you want to connect.
So, you can load the credentials to log back in:
const makeWASocket = require("@vreden/meta").default;
const { useMultiFileAuthState } = require("@vreden/meta");
const { state, saveCreds } = await useMultiFileAuthState('auth_info_baileys')
// will use the given state to connect
// so if valid credentials are available -- it'll connect without QR
const sock = makeWASocket({ auth: state })
// this will be called as soon as the credentials are updated
sock.ev.on('creds.update', saveCreds)[!IMPORTANT]
useMultiFileAuthStateis a utility function to help save the auth state in a single folder, this function serves as a good guide to help write auth & key states for SQL/no-SQL databases, which I would recommend in any production grade system.
[!NOTE] When a message is received/sent, due to signal sessions needing updating, the auth keys (
authState.keys) will update. Whenever that happens, you must save the updated keys (authState.keys.set()is called). Not doing so will prevent your messages from reaching the recipient & cause other unexpected consequences. TheuseMultiFileAuthStatefunction automatically takes care of that, but for any other serious implementation -- you will need to be very careful with the key state management.
- Baileys uses the EventEmitter syntax for events. They're all nicely typed up, so you shouldn't have any issues with an Intellisense editor like VS Code.
[!IMPORTANT] The events are these, it's important you see all events
You can listen to these events like this:
const sock = makeWASocket()
sock.ev.on('messages.upsert', ({ messages }) => {
console.log('got messages', messages)
})[!NOTE] This example includes basic auth storage too
const makeWASocket = require("@vreden/meta").default;
const { DisconnectReason, useMultiFileAuthState } = require("@vreden/meta");
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
- By default poll votes are encrypted and handled in
messages.update - That's a simple example
sock.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,
})
)
}
}
}
})-
getMessageis a store implementation (in your end)
- When you connect first time,
connection.updatewill be fired requesting you to restart sock - Then, history messages will be received in
messaging.history-set
- Baileys does not come with a defacto storage for chats, contacts, or messages. However, a simple in-memory implementation has been provided. The store listens for chat updates, new messages, message updates, etc., to always have an up-to-date version of the data.
[!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("@vreden/meta").default;
const { makeInMemoryStore } = require("@vreden/meta");
// 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.
-
idis the WhatsApp ID, calledjidtoo, of the person or group you're sending the message to.- It must be in the format
[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.
- Example for people:
- For broadcast lists, it's
[timestamp of creation]@broadcast. - For stories, the ID is
status@broadcast.
- It must be in the format
-
getContentType, returns the content type for any message -
getDevice, returns the device from message -
makeCacheableSignalKeyStore, make auth store more fast -
downloadContentFromMessage, download content from any message
-
Send all types of messages with a single function
- Here you can see all message contents supported, like text message
- Here you can see all options supported, like quote message
const jid: string const content: AnyMessageContent const options: MiscMessageGenerationOptions sock.sendMessage(jid, content, options)
// send a buttons message!
const buttons = [
{buttonId: 'id1', buttonText: {displayText: 'Button 1'}, type: 1},
{buttonId: 'id2', buttonText: {displayText: 'Button 2'}, type: 1},
{buttonId: 'id3', buttonText: {displayText: 'Button 3'}, type: 1}
]
const buttonMessage = {
text: "Hi it's button message",
footer: 'Hello World',
buttons: buttons,
headerType: 1
}
sock.sendMessage(id, buttonMessage)const flow = {
"name": "single_select",
"paramsJson": `{\"title\":\"Selection\",\"sections\":[{\"title\":\"Here Is title\",\"highlight_label\":\"meta native flow\",\"rows\":[{\"header\":\"header\",\"title\":\"title\",\"description\":\"description\",\"id\":\"id\"},{\"header\":\"header\",\"title\":\"title\",\"description\":\"description\",\"id\":\"id\"}]}]}`
}
const buttons = [
{buttonId: 'id1', buttonText: {displayText: 'Button 1'}, type: 1},
{buttonId: 'id2', buttonText: {displayText: 'Button 2'}, type: 1},
{buttonId: 'template', buttonText: {displayText: 'template'}, nativeFlowInfo: flow, type: 2}
]
const buttonMessage = {
text: "Hi it's button flow",
footer: 'Hello World',
buttons: buttons,
headerType: 1
}
sock.sendMessage(id, buttonMessage)const button = [{
"name": "single_select",
"buttonParamsJson": `{\"title\":\"Selection\",\"sections\":[{\"title\":\"Here Is title\",\"highlight_label\":\"meta native flow\",\"rows\":[{\"header\":\"header\",\"title\":\"title\",\"description\":\"description\",\"id\":\"id\"},{\"header\":\"header\",\"title\":\"title\",\"description\":\"description\",\"id\":\"id\"}]}]}`
},
{
"name": "quick_reply",
"buttonParamsJson": `{\"display_text\":\"quick_reply\",\"id\":\"here is id\"}`
},
{
"name": "cta_url",
"buttonParamsJson": `{\"display_text\":\"url\",\"url\":\"https://www.meta.com\",\"merchant_url\":\"https://www.meta.com\"}`
},
{
"name": "cta_call",
"buttonParamsJson": `{\"display_text\":\"call\",\"id\":\"message\"}`
},
{
"name": "cta_copy",
"buttonParamsJson": `{\"display_text\":\"copy\",\"id\":\"123456789\",\"copy_code\":\"message\"}`
},
{
"name": "cta_reminder",
"buttonParamsJson": `{\"display_text\":\"cta_reminder\",\"id\":\"message\"}`
},
{
"name": "cta_cancel_reminder",
"buttonParamsJson": `{\"display_text\":\"cta_cancel_reminder\",\"id\":\"message\"}`
},
{
"name": "address_message",
"buttonParamsJson": `{\"display_text\":\"address_message\",\"id\":\"message\"}`
},
{
"name": "send_location",
"buttonParamsJson": ""
}]
let msg = generateWAMessageFromContent(jid, {
interactiveMessage: proto.Message.InteractiveMessage.create({
body: {
text: "Hi it's interactive message"
},
footer: {
text: "WhatsApp API"
},
header: {
title: "Footer Text",
hasMediaAttachment: false
},
nativeFlowMessage: proto.Message.InteractiveMessage.NativeFlowMessage.create({
buttons: button,
})
})
}, {
quoted: message
})
sock.relayMessage(msg.key.remoteJid, msg.message, {
messageId: msg.key.id
})await sock.sendMessage(jid, { text: 'hello word' })await sock.sendMessage(jid, { text: 'hello word' }, { quoted: message })- @number is to mention in text, it's optional
await sock.sendMessage(
jid,
{
text: '@12345678901',
mentions: ['12345678901@s.whatsapp.net']
}
)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
}
}
)await sock.sendMessage(
jid,
{
poll: {
name: 'My Poll',
values: ['Option 1', 'Option 2', ...],
selectableCount: 1,
toAnnouncementGroup: false // or true
}
}
)- By default, wa does not have link generation when sent from the web
- Baileys has a function to generate the content for these link previews
- To enable this function's usage, add
link-preview-jsas a dependency to your project withyarn add link-preview-js - Send a link:
await 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
- When specifying a media url, Baileys never loads the entire buffer into memory; it even encrypts the media as a readable stream.
[!TIP] It's recommended to use Stream or Url to save memory
- Whatsapp doesn't support
.giffiles, that's why we send gifs as common.mp4video withgifPlaybackflag
await 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`
}
)- To audio message work in all devices you need to convert with some tool like
ffmpegwith this flags:codec: libopus //ogg file ac: 1 //one channel avoid_negative_ts make_zero- Example:
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'
}
)- You can send all messages above as
viewOnce, you only need to passviewOnce: truein content object
await 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
- You can pass all editable contents here
await sock.sendMessage(jid, {
text: 'updated text goes here',
edit: response.key,
});- For media messages, the thumbnail can be generated automatically for images & stickers provided you add
jimporsharpas a dependency in your project usingyarn add jimporyarn add sharp. - Thumbnails for videos can also be generated automatically, though, you need to have
ffmpeginstalled on your system.
If you want to save the media you received
const { createWriteStream } = require('fs');
const { downloadMediaMessage, getContentType } = require("@vreden/meta");
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)
}
}- WhatsApp automatically removes old media from their servers. For the device to access said media -- a re-upload is required by another device that has it. This can be accomplished using:
await sock.updateMediaMessage(msg)- You can obtain
callIdandcallFromfromcallevent
await sock.rejectCall(callId, callFrom)- A set of message keys must be explicitly marked read now.
- You cannot mark an entire 'chat' read as it were with Baileys Web. This means you have to keep track of unread messages.
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.
-
presencecan be one of these - The presence expires after about 10 seconds.
- This lets the person/group with
jidknow 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)- Supported times:
| 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
)- Ephemeral can be:
| Time | Seconds |
|---|---|
| Remove | 0 |
| 24h | 86.400 |
| 7d | 604.800 |
| 90d | 7.776.000 |
- You need to pass in Seconds, default is 7 days
// 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}`)- You need to have oldest message in chat
const msg = await getOldestMessageInChat(jid)
await sock.fetchMessageHistory(
50, //quantity (max: 50 per query)
msg.key,
msg.messageTimestamp
)- Messages will be received in
messaging.history-setevent
const status = await sock.fetchStatus(jid)
console.log('status: ' + status)- To get the display picture of some person/group
// 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')- To change your display picture or a group's
[!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)- To change group properties you need to be admin
// 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)- To create link with code use
'https://chat.whatsapp.com/' + code
const code = await sock.groupInviteCode(jid)
console.log('group code: ' + code)const code = await sock.groupRevokeInvite(jid)
console.log('New group code: ' + code)- Code can't have
https://chat.whatsapp.com/, only code
const 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)const 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)- Ephemeral can be:
| 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 userconst 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)- Like this, ephemeral can be:
| Time | Seconds |
|---|---|
| Remove | 0 |
| 24h | 86.400 |
| 7d | 604.800 |
| 90d | 7.776.000 |
const ephemeral = 86400
await sock.updateDefaultDisappearingMode(ephemeral)- Messages can be sent to broadcasts & stories. You need to add the following message options in sendMessage, like this:
await sock.sendMessage(
jid,
{
image: {
url: url
},
caption: caption
},
{
backgroundColor: backgroundColor,
font: font,
statusJidList: statusJidList,
broadcast: true
}
)-
Message body can be a
extendedTextMessageorimageMessageorvideoMessageorvoiceMessage, see here -
You can add
backgroundColorand other options in the message options, see here -
broadcast: trueenables 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
-
Example: Functionality to track the battery percentage of your phone. You enable logging and you'll see a message about your battery pop up in the console:
{ "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) - read more about this format here
[!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