Newsletters (channels)

Overview

Newsletters (also called channels) are broadcast-style messaging in WhatsApp. Unlike groups, newsletter messages are plaintext (no Signal E2E encryption) and flow one-way from admins to subscribers. This guide covers creating newsletters, managing subscriptions, sending messages, and handling live updates. All newsletter operations are accessed through the newsletter() method:

let newsletter = client.newsletter();

See Newsletter API reference for the full API.

let created = client.newsletter()
    .create("My Channel", Some("Channel description"))
    .await?;

println!("Created: {} ({})", created.name, created.jid);
println!("Invite code: {:?}", created.invite_code);

The returned NewsletterMetadata contains the channel’s JID (with @newsletter server), name, subscriber count, and invite code. See Newsletter API reference for details.

Listing subscribed newsletters

let newsletters = client.newsletter().list_subscribed().await?;

for nl in &newsletters {
    println!("{}: {} ({} subscribers)",
        nl.jid, nl.name, nl.subscriber_count);
}

See Newsletter API reference for details.

Fetching metadata

By JID

let metadata = client.newsletter().get_metadata(&newsletter_jid).await?;

println!("Name: {}", metadata.name);
println!("Description: {:?}", metadata.description);
println!("Subscribers: {}", metadata.subscriber_count);
println!("Verification: {:?}", metadata.verification);
println!("State: {:?}", metadata.state);

By invite code

let metadata = client.newsletter()
    .get_metadata_by_invite("invite-code-here")
    .await?;

println!("Found: {} ({})", metadata.name, metadata.jid);

See Newsletter API reference for all metadata fields.

Joining and leaving

let joined = client.newsletter().join(&newsletter_jid).await?;

println!("Joined '{}' as {:?}", joined.name, joined.role);

client.newsletter().leave(&newsletter_jid).await?;

See Newsletter API reference for details. You can update the name and/or description of a newsletter you own:

let updated = client.newsletter()
    .update(
        &newsletter_jid,
        Some("New Channel Name"),
        Some("Updated description"),
    )
    .await?;

println!("Updated: {}", updated.name);

Pass None for fields you don’t want to change. See Newsletter API reference for details.

Sending messages

Newsletter messages are plaintext — they bypass Signal encryption entirely. You send newsletter messages through the unified client.send_message() method, just like regular and group messages.

Text messages

use waproto::whatsapp as wa;

let message = wa::Message {
    conversation: Some("Hello subscribers!".to_string()),
    ..Default::default()
};

let msg_id = client.send_message(newsletter_jid, message).await?;

println!("Sent message: {}", msg_id);

The library automatically detects that the recipient is a newsletter JID and sends the message as plaintext (no Signal encryption). It also infers the correct type attribute (text, media, reaction, poll) and mediatype attribute from the message content. Stanza-level <meta> nodes (for polls, events, etc.) are also injected automatically, matching WhatsApp Web behavior.

For media messages (images, videos, etc.), you must upload the media separately using the newsletter-specific upload endpoint before sending. Text messages work directly.

Reactions

Send a reaction to a specific newsletter message using its server_id:

// React with thumbs up
client.newsletter()
    .send_reaction(&newsletter_jid, server_id, "👍")
    .await?;

// Remove reaction (empty string)
client.newsletter()
    .send_reaction(&newsletter_jid, server_id, "")
    .await?;

See Send API reference for details.

Editing and revoking messages

Channels use a plaintext edit/revoke flow that’s separate from DM and group messages. Call the helpers on client.newsletter() and pass the original message’s message_id (the wire stanza id returned by send_message, not the server_id used for reactions):

use waproto::whatsapp as wa;

// Edit a text message
let new_body = wa::Message {
    conversation: Some("Updated announcement".to_string()),
    ..Default::default()
};

client.newsletter()
    .edit_message(&newsletter_jid, message_id.clone(), new_body)
    .await?;

// Revoke (delete) it
client.newsletter()
    .revoke_message(&newsletter_jid, message_id)
    .await?;

Don’t call Client::edit_message or Client::revoke_message with a newsletter JID. The E2E send path now rejects channel JIDs outright (including from pin_message) so you get a clear error rather than a malformed encrypted stanza. Always go through client.newsletter() for channel edits and revokes.

Fetching message history

Retrieve past messages with pagination support:

use whatsapp_rust::NewsletterMessageType;
use wacore::types::message::EditAttribute;

// Fetch the latest 50 messages
let messages = client.newsletter()
    .get_messages(&newsletter_jid, 50, None)
    .await?;

for msg in &messages {
    println!("ID: {}, time: {}, type: {:?}",
        msg.server_id, msg.timestamp, msg.message_type);

    match msg.edit {
        EditAttribute::AdminEdit => println!("  (edited)"),
        EditAttribute::AdminRevoke => println!("  (revoked)"),
        _ => {}
    }

    if let Some(decoded) = &msg.message {
        if let Some(text) = &decoded.conversation {
            println!("  Text: {}", text);
        }
    }

    for reaction in &msg.reactions {
        println!("  {} x{}", reaction.code, reaction.count);
    }

    if msg.message_type == NewsletterMessageType::Poll {
        for vote in &msg.votes {
            println!("  poll option {}: {}", hex::encode(vote.option_hash), vote.count);
        }
    }

    if let Some(forwards) = msg.forwards_count {
        println!("  forwards: {}", forwards);
    }
}

Each NewsletterMessage also carries the message’s message_id (for edit_message and revoke_message), the <plaintext> media_type hint, <meta> metadata (original_timestamp, last_edit_timestamp_ms, poll_type, content_type, question_type, message_association_type, is_wamo_sub, admin_profile), and the opaque rcat bytes. See NewsletterMessage for the full field list.

forwards_count, views_count, and responses_count are Option<u64>. None means the server sent no counter, which is not the same as Some(0). views_count and responses_count are typically only populated when the viewer’s role in the channel entitles them to those figures.

An edited message updates timestamp and carries EditAttribute::AdminEdit in edit; last_edit_timestamp_ms records the edit time in milliseconds, while every other timestamp on NewsletterMessage is in seconds. A revoked message carries EditAttribute::AdminRevoke, has an empty <plaintext/>, message = None, and no forward counter.

Pagination

Use the server_id from a previous response to paginate backwards:

// Get messages before a specific server_id
let older = client.newsletter()
    .get_messages(&newsletter_jid, 20, Some(last_server_id))
    .await?;

See Newsletter API reference for details.

Live updates

Subscribe to real-time updates for a newsletter to receive reaction count changes:

let duration = client.newsletter()
    .subscribe_live_updates(&newsletter_jid)
    .await?;

println!("Subscribed for {}s", duration);

The server sends NewsletterLiveUpdate events with updated reaction counts. Handle them in your event handler:

use wacore::types::events::Event;

Event::NewsletterLiveUpdate(update) => {
    println!("Newsletter {} updated:", update.newsletter_jid);
    for msg in &update.messages {
        println!("  Message {}: {:?}", msg.server_id,
            msg.reactions.iter()
                .map(|r| format!("{} x{}", r.code, r.count))
                .collect::<Vec<_>>()
        );
    }
}

The subscription duration (typically 300 seconds) is returned by the server. You need to re-subscribe periodically to continue receiving live updates.

See Events reference for the full event type.

Error handling

Newsletter operations return MexError for metadata/management operations and anyhow::Error for message operations:

use whatsapp_rust::features::mex::MexError;

match client.newsletter().get_metadata(&jid).await {
    Ok(metadata) => println!("Found: {}", metadata.name),
    Err(MexError::PayloadParsing(msg)) => {
        eprintln!("Parse error: {}", msg);
    }
    Err(e) => eprintln!("Error: {}", e),
}

Key differences from groups

Feature	Newsletters	Groups
Encryption	Plaintext	Signal E2E
Messaging	One-way (admins only)	All members
JID server	`@newsletter`	`@g.us`
Reactions	Emoji counts (aggregated)	Per-message
API backend	MEX (GraphQL)	IQ stanzas

Next steps

Newsletter API reference — Full API details and types
Events — Handle newsletter live update events
Sending messages — Send messages to groups and contacts
MEX API — Understand the GraphQL layer used by newsletters

Getting Started

Core Concepts

Guides

Advanced

Overview

Listing subscribed newsletters

Fetching metadata

By JID

By invite code

Joining and leaving

Sending messages

Text messages

Reactions

Editing and revoking messages

Fetching message history

Live updates

Error handling

Key differences from groups

Next steps

​Overview

​Accessing the Newsletter API

​Creating a newsletter

​Listing subscribed newsletters

​Fetching metadata

​By JID

​By invite code

​Joining and leaving

​Join a newsletter

​Leave a newsletter

​Updating a newsletter

​Sending messages

​Text messages

​Reactions

​Editing and revoking messages

​Fetching message history

​Pagination

​Live updates

​Error handling

​Key differences from groups

​Next steps

Overview

Accessing the Newsletter API

Creating a newsletter

Listing subscribed newsletters

Fetching metadata

By JID

By invite code

Joining and leaving

Join a newsletter

Leave a newsletter

Updating a newsletter

Sending messages

Text messages

Reactions

Editing and revoking messages

Fetching message history

Pagination

Live updates

Error handling

Key differences from groups

Next steps