Baileys
v6.7.9
Esta biblioteca fue originalmente un proyecto para CS-2362 en la Universidad de Ashoka y no está afiliada ni respaldada de ninguna manera por WhatsApp. Úselo a su propia discreción. No envíes spam a la gente con esto. Desaconsejamos el uso de stalkerware, mensajería masiva o automatizada.
Baileys y sus encargados no se hacen responsables del mal uso de esta aplicación, como se indica en la licencia del MIT. Los mantenedores de Baileys no toleran de ninguna manera el uso de esta aplicación en prácticas que violen los Términos de servicio de WhatsApp. Los mantenedores de esta aplicación exigen la responsabilidad personal de sus usuarios de utilizar esta aplicación de manera justa, tal como está destinada a ser utilizada.
Baileys no requiere que Selenium ni ningún otro navegador interactúe con WhatsApp Web, lo hace directamente mediante un WebSocket . No ejecutar Selenium o Chromimum te ahorra medio giga de RAM :/ Baileys admite la interacción con las versiones web y multidispositivo de WhatsApp. Gracias a @pokearaujo por escribir sus observaciones sobre el funcionamiento de WhatsApp Multi-Device. Además, gracias a @Sigalor por escribir sus observaciones sobre el funcionamiento de WhatsApp Web y gracias a @Rhymen por la implementación .
El autor original tuvo que eliminar el repositorio original; ahora continuamos el desarrollo en este repositorio aquí. Este es el único repositorio oficial y lo mantiene la comunidad. Únete al Discord aquí
Consulte y ejecute example.ts para ver un ejemplo de uso de la biblioteca. El script cubre los casos de uso más comunes. Para ejecutar el script de ejemplo, descargue o clone el repositorio y luego escriba lo siguiente en una terminal:
cd path/to/Baileysyarnyarn exampleUtilice la versión estable:
yarn add @whiskeysockets/baileys
Utilice la versión Edge (no hay garantía de estabilidad, pero las últimas correcciones y funciones)
yarn add github:WhiskeySockets/Baileys
Luego importa tu código usando:
import makeWASocket from '@whiskeysockets/baileys' HACER
WhatsApp proporciona una API multidispositivo que permite a Baileys autenticarse como un segundo cliente de WhatsApp escaneando un código QR con WhatsApp en su teléfono.
import makeWASocket , { DisconnectReason } from '@whiskeysockets/baileys'
import { Boom } from '@hapi/boom'
async function connectToWhatsApp ( ) {
const sock = makeWASocket ( {
// can provide additional config here
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' , m => {
console . log ( JSON . stringify ( m , undefined , 2 ) )
console . log ( 'replying to' , m . messages [ 0 ] . key . remoteJid )
await sock . sendMessage ( m . messages [ 0 ] . key . remoteJid ! , { text : 'Hello there!' } )
} )
}
// run in main file
connectToWhatsApp ( )Si la conexión se realiza correctamente, verás un código QR impreso en la pantalla de tu terminal, escanéalo con WhatsApp en tu teléfono y ¡habrás iniciado sesión!
Puede configurar la conexión pasando un objeto SocketConfig .
Aquí se menciona toda la estructura SocketConfig con valores predeterminados:
type SocketConfig = {
/** the WS url to connect to WA */
waWebSocketUrl : string | URL
/** Fails the connection if the socket times out in this interval */
connectTimeoutMs : number
/** Default timeout for queries, undefined for no timeout */
defaultQueryTimeoutMs : number | undefined
/** ping-pong interval for WS connection */
keepAliveIntervalMs : number
/** proxy agent */
agent ?: Agent
/** pino logger */
logger : Logger
/** version to connect with */
version : WAVersion
/** override browser config */
browser : WABrowserDescription
/** agent used for fetch requests -- uploading/downloading media */
fetchAgent ?: Agent
/** should the QR be printed in the terminal */
printQRInTerminal : boolean
/** should events be emitted for actions done by this socket connection */
emitOwnEvents : boolean
/** provide a cache to store media, so does not have to be re-uploaded */
mediaCache ?: NodeCache
/** custom upload hosts to upload media to */
customUploadHosts : MediaConnInfo [ 'hosts' ]
/** time to wait between sending new retry requests */
retryRequestDelayMs : number
/** max msg retry count */
maxMsgRetryCount : number
/** time to wait for the generation of the next QR in ms */
qrTimeout ?: number ;
/** provide an auth state object to maintain the auth state */
auth : AuthenticationState
/** manage history processing with this control; by default will sync up everything */
shouldSyncHistoryMessage : ( msg : proto . Message . IHistorySyncNotification ) => boolean
/** transaction capability options for SignalKeyStore */
transactionOpts : TransactionCapabilityOptions
/** provide a cache to store a user's device list */
userDevicesCache ?: NodeCache
/** marks the client as online whenever the socket successfully connects */
markOnlineOnConnect : boolean
/**
* map to store the retry counts for failed messages;
* used to determine whether to retry a message or not */
msgRetryCounterMap ?: MessageRetryMap
/** width for link preview images */
linkPreviewImageThumbnailWidth : number
/** Should Baileys ask the phone for full history, will be received async */
syncFullHistory : boolean
/** Should baileys fire init queries automatically, default true */
fireInitQueries : boolean
/**
* generate a high quality link preview,
* entails uploading the jpegThumbnail to WA
* */
generateHighQualityLinkPreview : boolean
/** options for axios */
options : AxiosRequestConfig < any >
/**
* fetch a message from your store
* implement this so that messages failed to send (solves the "this message can take a while" issue) can be retried
* */
getMessage : ( key : proto . IMessageKey ) => Promise < proto . IMessage | undefined >
} const conn = makeWASocket ( {
... otherOpts ,
// can use Windows, Ubuntu here too
browser : Browsers . macOS ( 'Desktop' ) ,
syncFullHistory : true
} ) Obviamente no querrás seguir escaneando el código QR cada vez que quieras conectarte.
Entonces, puedes cargar las credenciales para volver a iniciar sesión:
import makeWASocket , { BufferJSON , useMultiFileAuthState } from '@whiskeysockets/baileys'
import * as fs from 'fs'
// 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
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 conn = makeWASocket ( { auth : state } )
// this will be called as soon as the credentials are updated
conn . ev . on ( 'creds.update' , saveCreds ) Nota: Cuando se recibe/envía un mensaje, debido a que las sesiones de señal necesitan actualización, las claves de autenticación ( authState.keys ) se actualizarán. Siempre que eso suceda, debe guardar las claves actualizadas (se llama authState.keys.set() ). No hacerlo evitará que sus mensajes lleguen al destinatario y provocará otras consecuencias inesperadas. La función useMultiFileAuthState se encarga automáticamente de eso, pero para cualquier otra implementación seria, deberá tener mucho cuidado con la administración del estado clave.
Baileys ahora activa el evento connection.update para informarle que algo se ha actualizado en la conexión. Estos datos tienen la siguiente estructura:
type ConnectionState = {
/** connection is now open, connecting or closed */
connection : WAConnectionState
/** the error that caused the connection to close */
lastDisconnect ?: {
error : Error
date : Date
}
/** is this a new login */
isNewLogin ?: boolean
/** the current QR code */
qr ?: string
/** has the device received all pending notifications while it was offline */
receivedPendingNotifications ?: boolean
}Nota: esto también ofrece actualizaciones del QR.
Baileys utiliza la sintaxis EventEmitter para eventos. Todos están muy bien escritos, por lo que no debería tener ningún problema con un editor Intellisense como VS Code.
Los eventos se escriben como se menciona aquí:
export type BaileysEventMap = {
/** connection state has been updated -- WS closed, opened, connecting etc. */
'connection.update' : Partial < ConnectionState >
/** credentials updated -- some metadata, keys or something */
'creds.update' : Partial < AuthenticationCreds >
/** history sync, everything is reverse chronologically sorted */
'messaging-history.set' : {
chats : Chat [ ]
contacts : Contact [ ]
messages : WAMessage [ ]
isLatest : boolean
}
/** upsert chats */
'chats.upsert' : Chat [ ]
/** update the given chats */
'chats.update' : Partial < Chat > [ ]
/** delete chats with given ID */
'chats.delete' : string [ ]
'labels.association' : LabelAssociation
'labels.edit' : Label
/** presence of contact in a chat updated */
'presence.update' : { id : string , presences : { [ participant : string ] : PresenceData } }
'contacts.upsert' : Contact [ ]
'contacts.update' : Partial < Contact > [ ]
'messages.delete' : { keys : WAMessageKey [ ] } | { jid : string , all : true }
'messages.update' : WAMessageUpdate [ ]
'messages.media-update' : { key : WAMessageKey , media ?: { ciphertext : Uint8Array , iv : Uint8Array } , error ?: Boom } [ ]
/**
* add/update the given messages. If they were received while the connection was online,
* the update will have type: "notify"
* */
'messages.upsert' : { messages : WAMessage [ ] , type : MessageUpsertType }
/** message was reacted to. If reaction was removed -- then "reaction.text" will be falsey */
'messages.reaction' : { key : WAMessageKey , reaction : proto . IReaction } [ ]
'message-receipt.update' : MessageUserReceiptUpdate [ ]
'groups.upsert' : GroupMetadata [ ]
'groups.update' : Partial < GroupMetadata > [ ]
/** apply an action to participants in a group */
'group-participants.update' : { id : string , participants : string [ ] , action : ParticipantAction }
'blocklist.set' : { blocklist : string [ ] }
'blocklist.update' : { blocklist : string [ ] , type : 'add' | 'remove' }
/** Receive an update on a call, including when the call was received, rejected, accepted */
'call' : WACallEvent [ ]
}Puedes escuchar estos eventos así:
const sock = makeWASocket ( )
sock . ev . on ( 'messages.upsert' , ( { messages } ) => {
console . log ( 'got messages' , messages )
} ) Baileys no viene con un almacenamiento de facto para chats, contactos o mensajes. Sin embargo, se ha proporcionado una implementación simple en memoria. La tienda escucha actualizaciones de chat, mensajes nuevos, actualizaciones de mensajes, etc., para tener siempre una versión actualizada de los datos.
Se puede utilizar de la siguiente manera:
import makeWASocket , { makeInMemoryStore } from '@whiskeysockets/baileys'
// the store maintains the data of the WA connection in memory
// can be written out to a file & read from it
const store = makeInMemoryStore ( { } )
// can be read from a file
store . readFromFile ( './baileys_store.json' )
// saves the state to a file every 10s
setInterval ( ( ) => {
store . writeToFile ( './baileys_store.json' )
} , 10_000 )
const sock = makeWASocket ( { } )
// will listen from this socket
// the store can listen from a new socket once the current socket outlives its lifetime
store . bind ( sock . ev )
sock . ev . on ( 'chats.upsert' , ( ) => {
// can use "store.chats" however you want, even after the socket dies out
// "chats" => a KeyedDB instance
console . log ( 'got chats' , store . chats . all ( ) )
} )
sock . ev . on ( 'contacts.upsert' , ( ) => {
console . log ( 'got contacts' , Object . values ( store . contacts ) )
} ) La tienda también proporciona algunas funciones simples como loadMessages que utilizan la tienda para acelerar la recuperación de datos.
Nota: Recomiendo encarecidamente crear su propio almacén de datos, especialmente para conexiones MD, ya que almacenar todo el historial de chat de alguien en la memoria es un terrible desperdicio de RAM.
Envía todo tipo de mensajes con una sola función:
import { MessageType , MessageOptions , Mimetype } from '@whiskeysockets/baileys'
const id = '[email protected]' // the WhatsApp ID
// send a simple text!
const sentMsg = await sock . sendMessage ( id , { text : 'oh hello there' } )
// send a reply messagge
const sentMsg = await sock . sendMessage ( id , { text : 'oh hello there' } , { quoted : message } )
// send a mentions message
const sentMsg = await sock . sendMessage ( id , { text : '@12345678901' , mentions : [ '[email protected]' ] } )
// send a location!
const sentMsg = await sock . sendMessage (
id ,
{ location : { degreesLatitude : 24.121231 , degreesLongitude : 55.1121221 } }
)
// send a contact!
const vcard = 'BEGIN:VCARDn' // metadata of the contact card
+ 'VERSION:3.0n'
+ 'FN:Jeff Singhn' // full name
+ 'ORG:Ashoka Uni;n' // the organization of the contact
+ 'TEL;type=CELL;type=VOICE;waid=911234567890:+91 12345 67890n' // WhatsApp ID + phone number
+ 'END:VCARD'
const sentMsg = await sock . sendMessage (
id ,
{
contacts : {
displayName : 'Jeff' ,
contacts : [ { vcard } ]
}
}
)
const reactionMessage = {
react : {
text : "?" , // use an empty string to remove the reaction
key : message . key
}
}
const sendMsg = await sock . sendMessage ( id , reactionMessage )link-preview-js como una dependencia a su proyecto con yarn add link-preview-js // send a link
const sentMsg = await sock . sendMessage ( id , { text : 'Hi, this was sent using https://github.com/adiwajshing/baileys' } )Enviar medios (vídeos, pegatinas, imágenes) es más fácil y eficiente que nunca.
import { MessageType , MessageOptions , Mimetype } from '@whiskeysockets/baileys'
// Sending gifs
await sock . sendMessage (
id ,
{
video : fs . readFileSync ( "Media/ma_gif.mp4" ) ,
caption : "hello!" ,
gifPlayback : true
}
)
await sock . sendMessage (
id ,
{
video : "./Media/ma_gif.mp4" ,
caption : "hello!" ,
gifPlayback : true ,
ptv : false // if set to true, will send as a `video note`
}
)
// send an audio file
await sock . sendMessage (
id ,
{ audio : { url : "./Media/audio.mp3" } , mimetype : 'audio/mp4' }
{ url : "Media/audio.mp3" } , // can send mp3, mp4, & ogg
)id es el ID de WhatsApp de la persona o grupo al que le estás enviando el mensaje.[country code][phone number]@s.whatsapp.net[email protected] .[email protected] .[timestamp of creation]@broadcast .status@broadcast .jimp o sharp como dependencia en su proyecto usando yarn add jimp o yarn add sharp . Las miniaturas de los vídeos también se pueden generar automáticamente, aunque es necesario tener instalado ffmpeg en el sistema. const info : MessageOptions = {
quoted : quotedMessage , // the message you want to quote
contextInfo : { forwardingScore : 2 , isForwarded : true } , // some random context info (can show a forwarded message with this too)
timestamp : Date ( ) , // optional, if you want to manually set the timestamp of the message
caption : "hello there!" , // (for media messages) the caption to send with the media (cannot be sent with stickers though)
jpegThumbnail : "23GD#4/==" , /* (for location & media messages) has to be a base 64 encoded JPEG if you want to send a custom thumb,
or set to null if you don't want to send a thumbnail.
Do not enter this field if you want to automatically generate a thumb
*/
mimetype : Mimetype . pdf , /* (for media messages) specify the type of media (optional for all media types except documents),
import {Mimetype} from '@whiskeysockets/baileys'
*/
fileName : 'somefile.pdf' , // (for media messages) file name for the media
/* will send audio messages as voice notes, if set to true */
ptt : true ,
/** Should it send as a disappearing messages.
* By default 'chat' -- which follows the setting of the chat */
ephemeralExpiration : WA_DEFAULT_EPHEMERAL
} const msg = getMessageFromStore ( '[email protected]' , 'HSJHJWH7323HSJSJ' ) // implement this on your end
await sock . sendMessage ( '[email protected]' , { forward : msg } ) // WA forward the message! Un conjunto de claves de mensajes debe marcarse explícitamente como leído ahora. En multidispositivo, no se puede marcar un "chat" completo como leído como si fuera con Baileys Web. Esto significa que debes realizar un seguimiento de los mensajes no leídos.
const key = {
remoteJid : '[email protected]' ,
id : 'AHASHH123123AHGA' , // id of the message you want to read
participant : '[email protected]' // the ID of the user that sent the message (undefined for individual chats)
}
// pass to readMessages function
// can pass multiple keys to read multiple messages as well
await sock . readMessages ( [ key ] ) El ID del mensaje es el identificador único del mensaje que estás marcando como leído. En un WAMessage , se puede acceder al messageID usando messageID = message.key.id .
await sock . sendPresenceUpdate ( 'available' , id ) Esto le permite a la persona/grupo con id saber si está en línea, fuera de línea, escribiendo, etc.
presence puede ser una de las siguientes:
type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused'La presencia expira después de unos 10 segundos.
Nota: En la versión multidispositivo de WhatsApp, si un cliente de escritorio está activo, WA no envía notificaciones automáticas al dispositivo. Si desea recibir dichas notificaciones, marque su cliente de Baileys como desconectado usando sock.sendPresenceUpdate('unavailable')
Si desea guardar los medios que recibió
import { writeFile } from 'fs/promises'
import { downloadMediaMessage } from '@whiskeysockets/baileys'
sock . ev . on ( 'messages.upsert' , async ( { messages } ) => {
const m = messages [ 0 ]
if ( ! m . message ) return // if there is no text or media message
const messageType = Object . keys ( m . message ) [ 0 ] // get what type of message it is -- text, image, video
// if the message is an image
if ( messageType === 'imageMessage' ) {
// download the message
const buffer = await downloadMediaMessage (
m ,
'buffer' ,
{ } ,
{
logger ,
// pass this so that baileys can request a reupload of media
// that has been deleted
reuploadRequest : sock . updateMediaMessage
}
)
// save to file
await writeFile ( './my-download.jpeg' , buffer )
}
}Nota: WhatsApp elimina automáticamente los medios antiguos de sus servidores. Para que el dispositivo acceda a dichos medios, es necesario volver a cargarlos en otro dispositivo que los tenga. Esto se puede lograr usando:
const updatedMediaMsg = await sock . updateMediaMessage ( msg ) const jid = '[email protected]' // can also be a group
const response = await sock . sendMessage ( jid , { text : 'hello!' } ) // send a message
// sends a message to delete the given message
// this deletes the message for everyone
await sock . sendMessage ( jid , { delete : response . key } ) Nota: la eliminación por uno mismo se admite a través de chatModify (siguiente sección)
const jid = '[email protected]'
await sock . sendMessage ( jid , {
text : 'updated text goes here' ,
edit : response . key ,
} ) ; WA utiliza una forma de comunicación cifrada para enviar actualizaciones de chat/aplicaciones. Esto se ha implementado en su mayor parte y puede enviar las siguientes actualizaciones:
Archivar un chat
const lastMsgInChat = await getLastMessageInChat ( '[email protected]' ) // implement this on your end
await sock . chatModify ( { archive : true , lastMessages : [ lastMsgInChat ] } , '[email protected]' )Silenciar/activar el silencio de un chat
// mute for 8 hours
await sock . chatModify ( { mute : 8 * 60 * 60 * 1000 } , '[email protected]' , [ ] )
// unmute
await sock . chatModify ( { mute : null } , '[email protected]' , [ ] )Marcar un chat como leído/no leído
const lastMsgInChat = await getLastMessageInChat ( '[email protected]' ) // implement this on your end
// mark it unread
await sock . chatModify ( { markRead : false , lastMessages : [ lastMsgInChat ] } , '[email protected]' )Eliminar un mensaje para mí
await sock . chatModify (
{ clear : { messages : [ { id : 'ATWYHDNNWU81732J' , fromMe : true , timestamp : "1654823909" } ] } } ,
'[email protected]' ,
[ ]
)Eliminar un chat
const lastMsgInChat = await getLastMessageInChat ( '[email protected]' ) // implement this on your end
await sock . chatModify ( {
delete : true ,
lastMessages : [ { key : lastMsgInChat . key , messageTimestamp : lastMsgInChat . messageTimestamp } ]
} ,
'[email protected]' )Anclar/desanclar un chat
await sock . chatModify ( {
pin : true // or `false` to unpin
} ,
'[email protected]' )Destacar/desmarcar un mensaje
await sock . chatModify ( {
star : {
messages : [ { id : 'messageID' , fromMe : true // or `false` }],
star : true // - true: Star Message; false: Unstar Message
} } , '[email protected]' ) ;Nota: si arruinas una de tus actualizaciones, WA puede cerrar la sesión de todos tus dispositivos y tendrás que iniciar sesión nuevamente.
const jid = '[email protected]' // can also be a group
// 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 id = '123456'
const [ result ] = await sock . onWhatsApp ( id )
if ( result . exists ) console . log ( ` ${ id } exists on WhatsApp, as jid: ${ result . jid } ` ) const status = await sock . fetchStatus ( "[email protected]" )
console . log ( "status: " + status ) const status = 'Hello World!'
await sock . updateProfileStatus ( status ) const name = 'My name'
await sock . updateProfileName ( name ) // for low res picture
const ppUrl = await sock . profilePictureUrl ( "[email protected]" )
console . log ( "download profile picture from: " + ppUrl )
// for high res picture
const ppUrl = await sock . profilePictureUrl ( "[email protected]" , 'image' ) const jid = '[email protected]' // can be your own too
await sock . updateProfilePicture ( jid , { url : './new-profile-picture.jpeg' } ) const jid = '[email protected]' // can be your own too
await sock . removeProfilePicture ( jid ) // the presence update is fetched and called here
sock . ev . on ( 'presence.update' , json => console . log ( json ) )
// request updates for a chat
await sock . presenceSubscribe ( "[email protected]" ) await sock . updateBlockStatus ( "[email protected]" , "block" ) // Block user
await sock . updateBlockStatus ( "[email protected]" , "unblock" ) // Unblock user const profile = await sock . getBusinessProfile ( "[email protected]" )
console . log ( "business description: " + profile . description + ", category: " + profile . category ) Por supuesto, reemplace xyz con una identificación real.
Para crear un grupo
// title & participants
const group = await sock . groupCreate ( "My Fab Group" , [ "[email protected]" , "[email protected]" ] )
console . log ( "created group with id: " + group . gid )
sock . sendMessage ( group . id , { text : 'hello there' } ) // say hello to everyone on the groupPara agregar/eliminar personas a un grupo o degradar/promover personas
// id & people to add to the group (will throw error if it fails)
const response = await sock . groupParticipantsUpdate (
"[email protected]" ,
[ "[email protected]" , "[email protected]" ] ,
"add" // replace this parameter with "remove", "demote" or "promote"
)Para cambiar el tema del grupo
await sock . groupUpdateSubject ( "[email protected]" , "New Subject!" )Para cambiar la descripción del grupo
await sock . groupUpdateDescription ( "[email protected]" , "New Description!" )Para cambiar la configuración del grupo
// only allow admins to send messages
await sock . groupSettingUpdate ( "[email protected]" , 'announcement' )
// allow everyone to send messages
await sock . groupSettingUpdate ( "[email protected]" , 'not_announcement' )
// allow everyone to modify the group's settings -- like display picture etc.
await sock . groupSettingUpdate ( "[email protected]" , 'unlocked' )
// only allow admins to modify the group's settings
await sock . groupSettingUpdate ( "[email protected]" , 'locked' )Para salir de un grupo
await sock . groupLeave ( "[email protected]" ) // (will throw error if it fails)Para obtener el código de invitación para un grupo
const code = await sock . groupInviteCode ( "[email protected]" )
console . log ( "group code: " + code )Para revocar el código de invitación en un grupo
const code = await sock . groupRevokeInvite ( "[email protected]" )
console . log ( "New group code: " + code )Para consultar los metadatos de un grupo
const metadata = await sock . groupMetadata ( "[email protected]" )
console . log ( metadata . id + ", title: " + metadata . subject + ", description: " + metadata . desc )Para unirse al grupo usando el código de invitación
const response = await sock . groupAcceptInvite ( "xxx" )
console . log ( "joined to: " + response ) Por supuesto, reemplace xxx con el código de invitación.
Para obtener información del grupo mediante código de invitación
const response = await sock . groupGetInviteInfo ( "xxx" )
console . log ( "group information: " + response )Para unirse al grupo usando groupInviteMessage
const response = await sock . groupAcceptInviteV4 ( "[email protected]" , groupInviteMessage )
console . log ( "joined to: " + response ) Por supuesto, reemplace xxx con el código de invitación.
Para obtener la solicitud de lista, únase
const response = await sock . groupRequestParticipantsList ( "[email protected]" )
console . log ( response )Para aprobar/rechazar solicitud unirse
const response = await sock . groupRequestParticipantsUpdate (
"[email protected]" , // id group,
[ "[email protected]" , "[email protected]" ] ,
"approve" // replace this parameter with "reject"
)
console . log ( response ) const privacySettings = await sock . fetchPrivacySettings ( true )
console . log ( "privacy settings: " + privacySettings ) 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 ) const duration = 86400 // 604800 | 7776000 | 0
await sock . updateDefaultDisappearingMode ( duration ) Se pueden enviar mensajes a transmisiones e historias. debe agregar las siguientes opciones de mensaje en sendMessage, como esta:
sock . sendMessage ( jid , { image : { url : url } , caption : caption } , { backgroundColor : backgroundColor , font : font , statusJidList : statusJidList , broadcast : true } )el cuerpo del mensaje puede ser un mensaje de texto extendido o un mensaje de imagen o un mensaje de video o un mensaje de voz
Puede agregar color de fondo y otras opciones en las opciones del mensaje.
transmisión: verdadero habilita el modo de transmisión
statusJidList: una lista de personas que puede obtener y que debe proporcionar, cuáles son las personas que recibirán este mensaje de estado.
Puede enviar mensajes a listas de difusión de la misma manera que envía mensajes a grupos y chats individuales.
En este momento, WA Web no admite la creación de listas de transmisión, pero aún puedes eliminarlas.
Los ID de transmisión tienen el formato 12345678@broadcast
Para consultar los destinatarios y el nombre de una lista de difusión:
const bList = await sock . getBroadcastListInfo ( "1234@broadcast" )
console . log ( `list name: ${ bList . name } , recps: ${ bList . recipients } ` ) Baileys está escrito teniendo en mente la funcionalidad personalizada. En lugar de bifurcar el proyecto y reescribir las partes internas, simplemente puedes escribir tus propias extensiones.
Primero, habilite el registro de mensajes no controlados de WhatsApp configurando:
const sock = makeWASocket ( {
logger : P ( { level : 'debug' } ) ,
} )Esto te permitirá ver todo tipo de mensajes que envía WhatsApp en la consola.
Algunos ejemplos:
Funcionalidad para rastrear el porcentaje de batería de su teléfono. Habilitas el registro y verás un mensaje emergente sobre tu batería en la consola: {"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"}
El "frame" es lo que es el mensaje recibido, tiene tres componentes:
tag : de qué se trata este marco (por ejemplo, el mensaje tendrá "mensaje")attrs : un par clave-valor de cadena con algunos metadatos (normalmente contiene el ID del mensaje)content : los datos reales (por ejemplo, un nodo de mensaje tendrá el contenido real del mensaje)Puede registrar una devolución de llamada para un evento usando lo siguiente:
// 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 ) => { } )Además, este repositorio ahora tiene licencia GPL 3 ya que utiliza libsignal-node
