Message Payload (MessageContext)

Every inbound message handler receives a single MessageContext object. It is decoded by zaileys from the raw Baileys WAMessage into a flat, predictable shape: IDs are normalized, LIDs are resolved to phone numbers where possible, and the heavy parts (group name, replied message, media bytes) are exposed as lazy functions so nothing is fetched until you ask for it.

client.on('message', (ctx) => {
  console.log(ctx.senderId, ctx.text)
  if (ctx.isGroup) ctx.reply('hi from a group')
})

The same payload shape is delivered to all of these events:

message · text · image · video · audio · document · sticker · mention · mention-all

mention / mention-all extend MessageContext with a couple of extra fields (the mentioned jids / group members). Everything documented here still applies.

Where it comes from

The raw Baileys message is run through the zaileys decode pipeline, which:

1. Unwraps ephemeral / view-once / caption wrappers to find the real content.
2. Normalizes jids and maps LID → phone number (with a short timeout) so senderId, roomId, mentions are stable PNs.
3. Derives flags from protocolMessage, pinInChatMessage, contextInfo, etc.
4. Defers the heavy work (group metadata, media download, quoted decode) behind functions you call on demand.

So plain fields are cheap to read; the function fields do real work (network/async) only when invoked.

Identity & IDs

Routing — who & where

Content

Flags (is…)

All computed from the message except isSpam (reserved, always false for now). A flag being false just means that state isn’t present on this message.

The is* flags reflect the state of this specific message. In your example most are false simply because it’s a normal forwarded image — only isForwarded and isGroup are true.

Methods (lazy / on-demand)

These are functions, not values, so zaileys doesn’t fetch metadata or download bytes unless you call them. That’s why they print as [Function] if you console.log the whole object.

client.on('message', async (ctx) => {
  const room = await ctx.roomName()
  const quoted = await ctx.replied()
  if (quoted) await ctx.reply(`you replied to: ${quoted.text}`)
  await ctx.react('👍')
})

citation

ctx.citation.authors(): Promise<boolean>
ctx.citation.banned():  Promise<boolean>

Predicates evaluated against your client’s citation config for the current sender:

• authors() → is the sender in your configured authors allow-list (array of jids or a predicate)?
• banned() → is the sender in your banned list?

Both resolve false when no citation config is set. Handy for owner/allow/deny gating without writing the jid check yourself.

media

Present only for messages that carry media or structured content. The shape depends on type.

Downloadable attachments (image · video · audio · document · sticker)

client.on('image', async (ctx) => {
  if (ctx.media?.type === 'image') {
    const buf = await ctx.media.buffer()
    // save / process buf
  }
})

The metadata fields arrive with the message, before any download. Use them to decide whether a download is worth it at all:

client.on('audio', async (ctx) => {
  if (ctx.media?.type !== 'audio') return
  if ((ctx.media.duration ?? 0) > 300) {
    return ctx.reply('Voice note terlalu panjang, maksimal 5 menit.')
  }
  const buf = await ctx.media.buffer()   // only now do we pay for the download
})

thumbnail lets you show a preview without downloading the original at all.

Structured media (no download)

Other chatTypes surface a typed media describing the content (no buffer()/stream()):

poll · contact · location / live-location · album · group-invite · product · order · payment · link (preview) · event · buttons · list · interactive · template

Each carries the fields relevant to it — e.g. location has latitude/longitude/name, poll has name/options/selectableCount, payment has kind/amount/currency, group-invite has groupId/inviteCode/expiresAt.

ad — where a lead came from

When someone taps a Click-to-WhatsApp ad on Facebook or Instagram, WhatsApp attaches the ad’s attribution to the first message of that chat. Later messages in the same chat do not carry it.

client.on('message', async (ctx) => {
  if (!ctx.ad) return
  await saveLead({ from: ctx.senderId, campaign: ctx.ad.ref, clickId: ctx.ad.clickId })
  await ctx.reply(`Halo! Kamu datang dari iklan "${ctx.ad.title}". Ada yang bisa dibantu?`)
})

business — verified business senders

Present only when WhatsApp itself verified the sender. Unlike senderName (a push name anyone can set to anything) this cannot be spoofed, so prefer it when you display or log who you are talking to.

chatType values

text · image · video · audio · document · sticker
poll · contact · location · live-location · event · album
group-invite · product · order · payment
buttons · list · interactive · template
unknown

Media types are detected first, then structured message types; anything unrecognized is unknown.

senderDevice values

Parsed from the sender’s device jid:

Config that shapes the payload

A few values come from your Client config rather than the raw message:

Gotchas

• chatId is a message id, not a jid. Reply with roomId / senderId, never chatId.
• timestamp is milliseconds. Already converted from WhatsApp’s seconds — don’t multiply by 1000.
• senderId is a phone-number jid (@s.whatsapp.net), resolved from LID when possible; senderLid holds the @lid form when present.
• Methods are lazy & mostly async. roomName(), replied(), media.buffer(), citation.* do real work — await them; they show as [Function] when you log the object.
• roomId follows the conversation, not the direction — safe as a reply target for both inbound and your own (isFromMe) messages.
• isSpam is reserved and always false today. Use forwardCount >= 5 for chain-message detection.
• Answer only live messages. After a reconnect WhatsApp replays everything you missed. Guard with if (ctx.isOld) return unless you deliberately want to process the backlog.
• Disappearing timers are inherited automatically. zaileys learns each chat’s timer from its inbound messages, so ctx.reply() and every client.send(...) into that chat — text, media, stickers, albums — carry it without you asking. Pass .disappearing(seconds) only to override it. Messages sent without the timer are the ones WhatsApp flags “this message won’t disappear”.
• senderUsername is usually null — WhatsApp sends the phone number or the username, never both. A username is the fallback handle for a sender whose number you cannot see, so it stays null for anyone whose phone number your account already knows (which is most people). It arrives mainly on group messages from LID-only senders. Never use it for authorization — senderId is the field for that. To ask for one explicitly, see client.getUsername(jid).