Sending Messages

client.send(recipient) returns a chainable, lazy message builder. You add exactly one content method (.text, .image, .poll, .event, .groupInvite, .product, …), optionally chain modifiers (.reply, .mentions, .disappearing, …), then await the builder to actually send. Every successful send resolves to the new message’s WAMessageKey, which you can later pass to client.edit/client.delete/client.forward.

import { Client } from 'zaileys'
 
const client = new Client({ authType: 'qr' })
 
client.on('connect', async () => {
  const key = await client.send('6281234567890@s.whatsapp.net').text('Hello there')
  console.log('sent', key.id)
})

The recipient: JID vs username

client.send(to) accepts either a fully-qualified JID or a plain phone number / username.

• A JID is used as-is. Recognised suffixes: @s.whatsapp.net (DM), @g.us (group), plus @lid, @newsletter, @broadcast, @c.us.
• Anything without a JID suffix is treated as a username/number and is resolved to a JID via WhatsApp’s onWhatsApp lookup at await time (the lookup is cached per client and de-duplicated for concurrent sends). If the number is not on WhatsApp, the send rejects with a USERNAME_NOT_FOUND error.

await client.send('6281234567890@s.whatsapp.net').text('explicit JID')
await client.send('120363012345678901@g.us').text('to a group')
await client.send('6281234567890').text('bare number — resolved automatically')

Media sources

Every media method (image, video, audio, document, sticker, and album items) accepts a MediaSource, which is one of:

await client.send(to).image('https://example.com/photo.jpg')        // remote URL
await client.send(to).image('./assets/photo.jpg')                   // local path
await client.send(to).image(new URL('file:///tmp/photo.jpg'))       // URL object
await client.send(to).image(myBuffer)                               // Buffer

The MIME type is auto-detected from the bytes. video() rejects with INVALID_OPTIONS if the detected MIME is not video/*; audio() and sticker() transcode the source automatically (see Media Processing). Failed loads (bad URL, missing file, non-2xx response) reject with a MEDIA_LOAD_FAILED error.

Text

The simplest message. Pass a string.

await client.send(to).text('Hello, world!')

await client.send(to).text('**bold** and _italic_ rendered as a card', { rich: true })

Image

await client.send(to).image('./photo.jpg', { caption: 'A nice view' })

Video note (PTV)

A round video note (push-to-video). Plays as a circular bubble in chat. Takes the same MediaSource as video(); the source must decode to a video/* MIME type.

await client.send(to).videoNote('./note.mp4')

Video

await client.send(to).video('./clip.mp4', { caption: 'Watch this' })

GIF

WhatsApp has no real GIF message type — animated “GIFs” are videos played in a silent loop. Use video() with gifPlayback: true. The source should be an MP4 (convert real .gif files first; see Media Processing).

await client.send(to).video('./animation.mp4', { gifPlayback: true, caption: 'lol' })

Audio

A regular audio file (music player UI). The source is transcoded to Opus automatically.

await client.send(to).audio('./song.mp3')

Voice note (PTT)

A voice note is just audio() with ptt: true (the default). When sent as a voice note, zaileys computes a waveform and duration so the chat shows the speech-bubble player.

await client.send(to).audio('./voice.ogg', { ptt: true })   // explicit
await client.send(to).audio('./voice.ogg')                  // ptt:true is the default

Document

Send any file as a downloadable attachment. fileName is required.

await client.send(to).document('./report.pdf', { fileName: 'Q3-report.pdf' })

await client.send(to).document(docBuffer, {
  fileName: 'notes.txt',
  mimetype: 'text/plain',
  caption: 'meeting notes',
})

Sticker

The source (image or animated webp/gif/video) is converted to a WhatsApp sticker automatically.

await client.send(to).sticker('./logo.png')

Location

await client.send(to).location(-6.2, 106.816666, { name: 'Jakarta', address: 'Indonesia' })

The first two arguments are latitude then longitude.

Contact (vCard)

Send a contact card. Pass a raw vCard string — it must start with BEGIN:VCARD.

const vcard = [
  'BEGIN:VCARD',
  'VERSION:3.0',
  'FN:Zaileys Bot',
  'TEL;type=CELL;type=VOICE;waid=6281234567890:+62 812-3456-7890',
  'END:VCARD',
].join('\n')
 
await client.send(to).contact(vcard)

contact() takes the vCard string directly (no options object). A string that does not begin with BEGIN:VCARD rejects with INVALID_OPTIONS.

Poll

await client.send(to).poll('Pick a colour', ['Red', 'Green', 'Blue'])

Signature: poll(question, options, opts?).

await client.send(to).poll('Toppings?', ['Cheese', 'Pepperoni', 'Mushroom'], {
  multipleChoice: true,
})

Album

Send multiple images and/or videos as a single grouped album. Internally zaileys sends one parent message followed by each child, and resolves to the parent WAMessageKey.

await client.send(to).album([
  { type: 'image', src: './a.jpg', caption: 'first' },
  { type: 'video', src: './b.mp4' },
  { type: 'image', src: imageBuffer },
])

Each item is an AlbumItem:

Event

Send a WhatsApp event (a scheduled meetup with a date, optional location, and optional call link).

await client.send(groupJid).event({
  name: 'Team standup',
  description: 'Daily sync',
  startAt: new Date('2026-07-01T09:00:00Z'),
  endAt: Date.now() + 3_600_000, // epoch ms also accepted
  location: { latitude: -6.2, longitude: 106.816666, name: 'HQ', address: 'Jakarta' },
  call: 'video',
})

Group invite

Send a tappable group invite card. You need the group’s invite code, which you fetch with client.group.inviteCode(groupJid).

const groupJid = '120363012345678901@g.us'
const code = await client.group.inviteCode(groupJid)
 
await client.send(to).groupInvite({
  jid: groupJid,
  code,
  subject: 'My Group',
  caption: 'Join us!',
})

Personal status (story)

Post to your own status by sending to status@broadcast and naming the audience with .audience(). Any content type works — text, image, video, voice note.

await client
  .send('status@broadcast')
  .image('./promo.jpg', { caption: 'Diskon hari ini' })
  .audience(['628111@s.whatsapp.net', '628222@s.whatsapp.net'])

.audience(jids) is the list of people who will see the status. It merges and de-duplicates across calls, so you can build it up in pieces.

Unlike group status, a personal status carries no backgroundColor/font options in zaileys yet. There is no contact-list default either: you always pass the audience explicitly, so a status is never broadcast wider than you intended.

Group status

Post a group status — the story-style update that appears at the top of a group. The recipient must be a group.

await client.send('120363012345678901@g.us').groupStatus('Pengumuman penting', {
  backgroundColor: '#25D366',
  font: 'calistoga',
})

Signature: groupStatus(text, opts?).

Both a hex string and a raw ARGB integer are verified to render. Note that baileys’ own assertColor returns undefined for numeric input, so zaileys parses colours itself rather than delegating.

Reposting someone else’s message

Pass a message instead of text and it becomes the status — text, image, video, or voice note. Any inherited quote chain is cleared, so the status does not carry the original’s context.

client.on('message', async (ctx) => {
  if (ctx.text !== '!status') return
 
  const original = await ctx.replied()
  if (!original) return ctx.reply('Reply to a message first')
 
  await client.send(ctx.chatId).groupStatus(original)
})

Media status

Post an image, video, or voice note as a group status. Pass fresh media directly, or repost an existing media message — either way the bytes are uploaded fresh, because a status needs its own upload and cannot reuse another message’s media pointers.

await client.send(groupJid).groupStatus({
  image: './poster.jpg',
  caption: 'Promo hari ini',
})
 
await client.send(groupJid).groupStatus({ audio: './voice.ogg', ptt: true })

line 469   const mediaType = getMediaType(message)     // reads the RAW message
line 471   extraAttrs['mediatype'] = mediaType         // lands on the `enc` node
line 372   patchMessageBeforeSending(message, jids)    // runs AFTER

Product

Send a business catalog product card. Requires a WhatsApp Business account.

await client.send(to).product({
  image: './shoe.jpg',
  title: 'Running Shoes',
  businessOwnerId: '6281234567890@s.whatsapp.net',
  description: 'Lightweight trainers',
  price: 50, // currency units → renders as 50.00
  currency: 'USD',
  body: 'Limited stock',
  footer: 'Free shipping',
})

Phone number sharing

Two no-argument helpers for exchanging phone numbers.

await client.send(to).requestPhoneNumber()   // ask the recipient to share theirs
await client.send(to).sharePhoneNumber()     // share your own number

Limit sharing

Toggle WhatsApp’s forward/sharing limit on a chat.

await client.send(to).limitSharing()       // enable (default)
await client.send(to).limitSharing(false)  // disable

Modifiers (chaining)

Modifiers are orthogonal and can be chained on top of any content method, in any order, before the await.

await client
  .send(to)
  .text('Heads up, team!')
  .reply(quotedKeyOrMessage)                    // quote a message
  .mentions(['6281234567890@s.whatsapp.net'])   // tag specific JIDs
  .disappearing(86400)                          // ephemeral, in seconds

.reply(quoted)

Quote an earlier message. Accepts either a full WAMessage (best — shows the quoted body) or a bare WAMessageKey. Passing null/undefined rejects with INVALID_OPTIONS.

const key = await client.send(to).text('Original')
await client.send(to).text('A reply').reply(key)
 
// inside a handler, you typically already have the full message:
client.on('text', async (ctx) => {
  await client.send(ctx.senderId).text('got it').reply(ctx.message())
})

.mentions(jids)

Tag specific participants. Each entry must be a JID-shaped string containing @. Repeated calls merge and de-duplicate; an empty array rejects with INVALID_OPTIONS.

await client
  .send(groupJid)
  .text('@alice @bob standup in 5')
  .mentions(['6281111111111@s.whatsapp.net', '6282222222222@s.whatsapp.net'])

.mentionAll()

Tag every member of a group (no arguments).

await client.send(groupJid).text('Important: read this').mentionAll()

.disappearing(seconds)

Send as an ephemeral/disappearing message. Takes a positive integer number of seconds (e.g. 86400 = 24h, 604800 = 7 days). Non-positive or non-integer values reject with INVALID_OPTIONS.

await client.send(to).text('self-destructs in a day').disappearing(86400)

.to(recipient)

Reassign the recipient on an init-state builder before adding content (rarely needed since client.send(to) already sets it).

await client.send('placeholder').to('6281234567890@s.whatsapp.net').text('redirected')

The return value

Every successful send resolves to a WAMessageKey:

import type { WAMessageKey } from 'zaileys'
 
const key: WAMessageKey = await client.send(to).text('keep this key')
// key.id, key.remoteJid, key.fromMe …
 
await client.edit(key).text('edited text')
await client.delete(key, { forEveryone: true })
await client.forward(key, anotherJid)

For albums, the returned key is the parent message’s key. See Client for edit, delete, forward, and react.

Error handling

The builder throws typed ZaileysBuilderErrors. Common codes:

try {
  await client.send(to).document(buf, { fileName: 'x.pdf' })
} catch (err) {
  console.error('send failed:', err)
}

See Error Handling for the full taxonomy.

What’s next

This page covers the plain content types. For richer experiences:

• Interactive Messages — .buttons(), .list(), .carousel(), .template().
• Rich Responses — .text(..., { rich: true }) AIRich cards (markdown, LaTeX).
• Media Processing — converting, resizing, and inspecting media before sending.
• Client — edit, delete, forward, react, and broadcast helpers.