Professional WhatsApp Web API Library — Built for the Next Generation of Bots
Fork-optimized from Baileys · Powered by CiaaTopUp-Libsignal · Maintained by CiaaTopUp-Official
CTbaileys adalah library WhatsApp Web API profesional yang dioptimalkan dari basis Baileys. Dikelola oleh CiaaTopUp-Official, library ini dirancang untuk performa tinggi, stabilitas maksimal, dan kemudahan integrasi ke berbagai proyek bot WhatsApp modern. Kini ditenagai penuh oleh CiaaTopUp-libsignal untuk proses enkripsi tingkat tinggi.
| Fitur | Keterangan |
|---|---|
| 🔀 Multi-Device | Dukungan penuh sistem multi-device WhatsApp terbaru |
| 🔐 End-to-End Encryption | Enkripsi pesan standar industri |
| ⚡ Turbo Handshake | Inisialisasi koneksi yang sangat cepat |
| 🧠 Memory Optimized | Penggunaan RAM yang ringan dan efisien |
| 📦 Semua Jenis Pesan | Teks, Media, Button, Poll, Sticker, dan lainnya |
| 🆔 LID & JID Mapping | Pemetaan @lid dan @jid lengkap |
npm install CTbaileys
# atau
yarn add CTbaileys
const { default: makeWASocket, useMultiFileAuthState } = require("CTbaileys")
async function startBot() {
const { state, saveCreds } = await useMultiFileAuthState('./session')
const sock = makeWASocket({
auth: state,
printQRInTerminal: true
})
sock.ev.on('creds.update', saveCreds)
sock.ev.on('connection.update', ({ connection }) => {
if (connection === 'open') console.log('✅ CTbaileys: Bot Connected!')
})
}
startBot()
await sock.sendMessage('6281234567890@s.whatsapp.net', {
stickerPack: {
name: 'CTbaileys Sticker',
publisher: 'CTbaileys',
description: 'Sticker pack custom dari CTbaileys',
cover: { url: './assets/cover.png' },
stickers: [
{ sticker: { url: './assets/sticker-1.webp' }, emojis: ['😀'] },
{ sticker: { url: './assets/sticker-2.webp' }, emojis: ['🔥'] },
{ sticker: { url: './assets/sticker-3.png' }, emojis: ['🚀'] }
]
}
})
stickerPackname: nama pack stickerpublisher: nama author/publisherdescription: deskripsi packcover: cover/tray icon, bisa file path, buffer, stream, atau URLstickers: array isi sticker, minimal 1 maksimal 60sticker: media tiap sticker, bisa WebP/PNG/JPG. Jika bukan WebP akan dicoba dikonversi otomatisemojis: emoji untuk sticker terkaitaccessibilityLabel: label opsionalpackId: opsional, jika tidak diisi akan dibuat otomatissharp agar konversi gambar ke WebP lebih stabil.sharp tidak ada, library akan mencoba memakai jimp.WhatsApp provides a multi-device API that allows CTbaileys 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("CTbaileys")
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("CTbaileys")
const sock = makeWASocket({
// can provide additional config here
printQRInTerminal: false //need to be false
})
- Normal Pairing
if (!sock.authState.creds.registered) {
const number = 'XXXXXXXXXXX'
const code = await sock.requestPairingCode(number)
console.log(code)
}
- Costum Pairing
if (!sock.authState.creds.registered) {
const pair = "12345678" // only 8 digit numbers or letters (no more or less)
const number = 'XXXXXXXXXXX'
const code = await sock.requestPairingCode(number, pair)
console.log(code)
}
syncFullHistory as trueconst sock = makeWASocket({
...otherOpts,
// can use Windows, Ubuntu here too
browser: Browsers.macOS('Desktop'),
syncFullHistory: true
})
If you use CTbaileys for groups, we recommend you to set cachedGroupMetadata in 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)
})
getMessage config in socket like this:
const sock = makeWASocket({
getMessage: async (key) => await getMessageFromStore(key)
})
markOnlineOnConnect to false
const 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("CTbaileys").default;
const { useMultiFileAuthState } = require("CTbaileys");
const { state, saveCreds } = await useMultiFileAuthState('auth_info_CTbaileys')
// 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.
[!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("CTbaileys").default;
const { DisconnectReason, useMultiFileAuthState } = require("CTbaileys");
const Boom = require('@hapi/boom');
async function connectToWhatsApp () {
const { state, saveCreds } = await useMultiFileAuthState('auth_info_CTbaileys')
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("CTbaileys").default;
const { makeInMemoryStore } = require("CTbaileys");
// 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('./CTbaileys_store.json')
// saves the state to a file every 10s
setInterval(() => {
store.writeToFile('./CTbaileys_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 messageDigunakan untuk mengirim status WhatsApp (story) Grup baik berupa teks maupun media ke status@broadcast.
[!NOTE] Fungsi ini sudah otomatis mendeteksi tipe konten (teks, gambar, video, audio). Jika teks dan media digabung, hanya satu yang akan dikirim tergantung prioritas konten.
await conn.upswgc(m.chat, { text: "Halo dari upswgc versi final!" })
await conn.upswgc(m.chat, {
image: { url: "https://m.media-amazon.com/images/S/pv-target-images/f75db71efd62ea2eff81bd7cc01c44a9344b4ac18615ab71a80f58459ddf8791.jpg" },
caption : "apasi"
});
await conn.upswgc(m.chat, {
video: { url: "https://m.media-amazon.com/images/S/pv-target-images/f75db71efd62ea2eff81bd7cc01c44a9344b4ac18615ab71a80f58459ddf8791.jpg" },
caption : "apasi"
});
await conn.upswgc(m.chat, {
audio: { url: "https://raw.githubusercontent.com/CiaaSoft-Official/CTbaileys/main/assets/sample.opus" },
caption : "apasi"
});
[!TIP] Jika kamu ingin mengirim ke story + broadcast sekaligus, gunakan fungsi sendMessage() dengan broadcast: true seperti dijelaskan pada bagian sebelumnya.
Send all types of messages with a single function
const jid: string
const content: AnyMessageContent
const options: MiscMessageGenerationOptions
sock.sendMessage(jid, content, options)
// send a buttons message!
sock.sendMessage(jid, {
text: "Hello World !",
footer: "CTbaileys - 2026",
buttons: [
{
buttonId: `🚀`,
buttonText: {
displayText: '🗿'
},
type: 1
}
],
headerType: 1,
viewOnce: true
},{ quoted: null })
sock.sendMessage(jid, {
text: "Hello Wolrd !;",
footer: "© CiaaTopUp-Official Dev",
buttons: [
{
buttonId: '.tes',
buttonText: {
displayText: 'TESTING BOT'
},
type: 1,
},
{
buttonId: ' ',
buttonText: {
displayText: 'PRIVATE SCRIPT'
},
type: 1,
},
{
buttonId: 'action',
buttonText: {
displayText: 'ini pesan interactiveMeta'
},
type: 4,
nativeFlowInfo: {
name: 'single_select',
paramsJson: JSON.stringify({
title: 'message',
sections: [
{
title: 'CTbaileys - 2026',
highlight_label: '😜',
rows: [
{
header: 'HEADER',
title: 'TITLE',
description: 'DESCRIPTION',
id: 'YOUR ID',
},
{
header: 'HEADER',
title: 'TITLE',
description: 'DESCRIPTION',
id: 'YOUR ID',
},
],
},
],
}),
},
},
],
headerType: 1,
viewOnce: true
}, { quoted: m });
let msg = generateWAMessageFromContent(m.chat, {
viewOnceMessage: {
message: {
"messageContextInfo": {
"deviceListMetadata": {},
"deviceListMetadataVersion": 2
},
interactiveMessage: proto.Message.InteractiveMessage.create({
body: proto.Message.InteractiveMessage.Body.create({
text: "CiaaTopUp-Official"
}),
footer: proto.Message.InteractiveMessage.Footer.create({
text: "Bot"
}),
header: proto.Message.InteractiveMessage.Header.create({
title: "Igna",
subtitle: "test",
hasMediaAttachment: false
}),
nativeFlowMessage: proto.Message.InteractiveMessage.NativeFlowMessage.create({
buttons: [
{
"name": "single_select",
"buttonParamsJson": "{\"title\":\"title\",\"sections\":[{\".menu\":\".play dj webito\",\"highlight_label\":\"label\",\"rows\":[{\"header\":\"header\",\"title\":\"title\",\"description\":\"description\",\"id\":\"id\"},{\"header\":\"header\",\"title\":\"title\",\"description\":\"description\",\"id\":\"id\"}]}]}"
},
{
"name": "cta_reply",
"buttonParamsJson": "{\"display_text\":\"quick_reply\",\"id\":\"message\"}"
},
{
"name": "cta_url",
"buttonParamsJson": "{\"display_text\":\"url\",\"url\":\"https://www.google.com\",\"merchant_url\":\"https://www.google.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\":\"Recordatorio\",\"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": ""
}
],
})
})
}
}
}, {})
return 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 })
await sock.sendMessage(
jid,
{
text: '@12345678901',
mentions: ['12345678901@s.whatsapp.net']
}
)
await sock.StatusMentions(
{
text: "Hello", // or image / video / audio ( url or buffer )
},
[
"123456789123456789@g.us",
"123456789@s.whatsapp.net",
// Enter jid chat here
]
)
await client.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
}
)
await client.sendMessage(
jid,
{
buttonReply: {
text: 'Text',
nativeFlow: {
version: 3,
},
},
type: 'interactive',
ephemeral: true,
}
)
- Example non media sticker
await client.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 client.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 client.sendMessage(
jid,
{
requestPayment: {
currency: "IDR",
amount: "10000000",
from: "123456@s.whatsapp.net",
sticker: { url: Sticker Url },
background: { ...background of the message }
}
},
{ quoted : message }
)
await client.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 }
)
- Example non header media
await client.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 client.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 client.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
}
}
)
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/CTbaileys'
}
)
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("CTbaileys");
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 CTbaileys 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 CTbaileys 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 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.
const bList = await sock.getBroadcastListInfo('1234@broadcast')
console.log (`list name: ${bList.name}, recps: ${bList.recipients}`)
CTbaileys 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
Proyek ini tidak berafiliasi dengan WhatsApp Inc.
Gunakan secara bertanggung jawab dan hindari aktivitas ilegal atau penyalahgunaan.
📘 Documentation powered by CTbaileys
🧑💻 Modified and Presented by CTbaileys
Gunakan field stickerPack pada sendMessage untuk mengirim satu paket sticker sekaligus.
Catatan penting: stickerPack sekarang bisa menerima campuran sticker statis dan video/animated (webp/png/jpg/jpeg/gif/webm/mp4) lalu mengonversinya ke WebP otomatis saat proses kirim, selama ffmpeg tersedia di server. Format tgs/Lottie tetap butuh preview/konverter tambahan di luar runtime ini.
await sock.sendMessage(jid, {
stickerPack: {
name: 'Nama Pack',
publisher: 'Nama Publisher',
description: 'Deskripsi singkat',
cover: { url: './cover.png' },
stickers: [
{ sticker: { url: './1.webp' }, emojis: ['🙂'] },
{ sticker: { url: './2.png' }, emojis: ['🎉'] }
]
}
})
cover dan setiap item sticker menerima format media yang sama seperti pengiriman media biasa: path lokal, URL, Buffer, atau stream.
FAQs
Professional Whatsapp Web API Library
The npm package ctbaileys receives a total of 6 weekly downloads. As such, ctbaileys popularity was classified as not popular.
We found that ctbaileys 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.
Threat Research
/Security News
Compromised maintainer accounts pushed malicious @ethersphere/bee-js 13.3.0 and Swarm Desktop 0.56.2, reusing SleepyDuck’s Ethereum-addressed C2 infrastructure.
Security News
Socket has released a free Certified Patch for a critical Rails Active Storage vulnerability, giving developers time to upgrade to a secure Rails version.
Security News
/Threat Research
A malicious Ruby gem runs a credential-stealing worm during installation, poisons AI coding tools, and can wipe files when a stolen GitHub token is revoked.