Newsletter - WhatsApp Rust

The Newsletter feature provides methods for managing WhatsApp newsletter channels, including creation, subscription management, admin operations, reactions, and live updates. Newsletter operations use MEX (GraphQL) for metadata/management and IQ stanzas for message operations. Newsletter message sending is handled by the unified client.send_message() method — see the Send API. Reactions remain on the Newsletter struct because they use a different stanza format.

Newsletter messages are plaintext — they are not encrypted with the Signal protocol.

Access

Access newsletter operations through the client:

let newsletter = client.newsletter();

Methods

list_subscribed

List all newsletters the user is subscribed to.

pub async fn list_subscribed(&self) -> Result<Vec<NewsletterMetadata>, NewsletterError>

Returns:

Vec<NewsletterMetadata> — List of subscribed newsletters

Example:

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

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

get_metadata

Fetch metadata for a newsletter by its JID.

pub async fn get_metadata(&self, jid: &Jid) -> Result<NewsletterMetadata, NewsletterError>

Parameters:

jid — Newsletter JID (server must be newsletter)

Returns:

NewsletterMetadata — Full newsletter metadata

Example:

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

println!("Name: {}", metadata.name);
println!("Subscribers: {}", metadata.subscriber_count);
println!("Verified: {:?}", metadata.verification);

get_metadata_by_invite

Fetch metadata for a newsletter by its invite code.

pub async fn get_metadata_by_invite(
    &self,
    invite_code: &str,
) -> Result<NewsletterMetadata, NewsletterError>

Parameters:

invite_code — Newsletter invite code string

Returns:

NewsletterMetadata — Full newsletter metadata

Example:

let metadata = client.newsletter()
    .get_metadata_by_invite("ABC123")
    .await?;

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

create

Create a new newsletter.

pub async fn create(
    &self,
    name: &str,
    description: Option<&str>,
) -> Result<NewsletterMetadata, NewsletterError>

Parameters:

name — Newsletter name
description — Optional description

Returns:

NewsletterMetadata — Metadata of the newly created newsletter

Example:

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

println!("Created: {} ({})", created.name, created.jid);

join

Join (subscribe to) a newsletter.

pub async fn join(&self, jid: &Jid) -> Result<NewsletterMetadata, NewsletterError>

Parameters:

jid — Newsletter JID to join

Returns:

NewsletterMetadata — Metadata with the viewer’s role set to Subscriber

Example:

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

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

leave

Leave (unsubscribe from) a newsletter.

pub async fn leave(&self, jid: &Jid) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID to leave

Example:

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

update

Update a newsletter’s name and/or description.

pub async fn update(
    &self,
    jid: &Jid,
    name: Option<&str>,
    description: Option<&str>,
) -> Result<NewsletterMetadata, NewsletterError>

Parameters:

jid — Newsletter JID
name — New name, or None to keep the current name
description — New description, or None to keep the current description

Returns:

NewsletterMetadata — Updated metadata

Example:

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

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

set_picture

Replace a newsletter’s picture. Carried by the same mutation as update — WhatsApp Web edits the picture as base64-encoded JPEG bytes — so the response is the newsletter’s refreshed metadata.

pub async fn set_picture(
    &self,
    jid: &Jid,
    jpeg: &[u8],
) -> Result<NewsletterMetadata, NewsletterError>

Parameters:

jid — Newsletter JID
jpeg — JPEG-encoded image bytes

Returns:

NewsletterMetadata — Updated metadata

Example:

let updated = client.newsletter()
    .set_picture(&newsletter_jid, &jpeg_bytes)
    .await?;

remove_picture

Remove a newsletter’s picture.

pub async fn remove_picture(&self, jid: &Jid) -> Result<NewsletterMetadata, NewsletterError>

Parameters:

jid — Newsletter JID

Returns:

NewsletterMetadata — Updated metadata

Example:

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

delete

Delete a newsletter. Owner-only.

pub async fn delete(&self, jid: &Jid) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID

Example:

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

change_owner

Transfer a newsletter’s ownership to another user. Owner-only.

pub async fn change_owner(&self, jid: &Jid, user: &Jid) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID
user — The new owner. May be a LID or a phone-number JID — a phone-number JID is resolved to its LID before the request. If no LID is known for the target, the call fails with NewsletterError::InvalidRequest rather than sending an address the server can’t route.

Example:

client.newsletter()
    .change_owner(&newsletter_jid, &new_owner_jid)
    .await?;

demote_admin

Demote an admin of a newsletter back to subscriber. Owner-only.

pub async fn demote_admin(&self, jid: &Jid, user: &Jid) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID
user — The admin to demote. Same LID resolution as change_owner.

Example:

client.newsletter()
    .demote_admin(&newsletter_jid, &admin_jid)
    .await?;

get_admin_info

Fetch a newsletter’s admin-side information, including its admin count.

pub async fn get_admin_info(&self, jid: &Jid) -> Result<NewsletterAdminInfo, NewsletterError>

Parameters:

jid — Newsletter JID

Returns:

NewsletterAdminInfo — Admin count, the viewer’s own admin profile, and the admin-profiles setting

The admin count has no query of its own — it rides along with the admin profile and the admin-profiles setting in this one response. The server only answers it for admins and owners, so admin_count is None for everyone else.

Example:

let info = client.newsletter().get_admin_info(&newsletter_jid).await?;

println!("Admins: {:?}", info.admin_count);

get_followers

List up to count of a newsletter’s followers (subscribers).

pub async fn get_followers(
    &self,
    jid: &Jid,
    count: u32,
) -> Result<Vec<NewsletterFollower>, NewsletterError>

Parameters:

jid — Newsletter JID
count — Maximum number of followers to return

This operation takes no cursor — WhatsApp Web asks for a single page clamped to its subscriber-list limit, so count is the whole request. There is no built-in pagination.

Returns:

Vec<NewsletterFollower> — One page of followers

Example:

let followers = client.newsletter()
    .get_followers(&newsletter_jid, 100)
    .await?;

for f in &followers {
    println!("{}: {:?}", f.jid, f.role);
}

set_follower_mute

Mute or unmute a newsletter’s follower-activity notifications (WhatsApp Web’s MUTE_FOLLOWER_ACTIVITY). Sent via MEX as a user-setting update.

pub async fn set_follower_mute(&self, jid: &Jid, muted: bool) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID
muted — true silences notifications, false re-enables them

Example:

// Mute
client.newsletter().set_follower_mute(&newsletter_jid, true).await?;

// Unmute
client.newsletter().set_follower_mute(&newsletter_jid, false).await?;

set_admin_mute

Mute or unmute a newsletter’s admin-activity notifications (WhatsApp Web’s MUTE_ADMIN_ACTIVITY). Only meaningful for owners/admins.

pub async fn set_admin_mute(&self, jid: &Jid, muted: bool) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID
muted — true silences admin-activity notifications, false re-enables them

Example:

client.newsletter().set_admin_mute(&newsletter_jid, true).await?;

The mute state is sent as ON/OFF; the mute expiration is local database state and is never put on the wire, matching WhatsApp Web’s WAWebNewsletterUpdateUserSettingJob.

Sending messages

Newsletter message sending is handled by the unified client.send_message() method. See the Send API reference for full details.

use waproto::whatsapp as wa;

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

// Pass a newsletter JID directly to send_message
let msg_id = client.send_message(newsletter_jid, message).await?;

The library detects newsletter recipients automatically and sends messages as plaintext (no Signal encryption), with the correct type and mediatype stanza attributes inferred from the message content. Stanza-level <meta> nodes (for polls, events, etc.) are also included automatically, matching WhatsApp Web behavior.

Newsletter::send_message() was removed. Use client.send_message() instead — it accepts newsletter, group, and direct message JIDs.

send_reaction

Send a reaction to a newsletter message.

pub async fn send_reaction(
    &self,
    jid: &Jid,
    server_id: u64,
    reaction: &str,
) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID
server_id — Server-assigned ID of the message to react to
reaction — Emoji code (e.g., "👍", "❤️"), or empty string to remove

Example:

// Add a reaction
client.newsletter()
    .send_reaction(&newsletter_jid, server_id, "👍")
    .await?;

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

edit_message

Edit a previously-sent newsletter message. Channel messages are plaintext, so the edit is sent as a <message edit="1"> stanza with the new protobuf body — not through the E2E send path.

pub async fn edit_message(
    &self,
    jid: &Jid,
    message_id: impl Into<String>,
    new_content: wa::Message,
) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID. Non-newsletter JIDs are rejected with an error; use Client::edit_message for DMs and groups.
message_id — The target message’s message_id (the wire stanza id, as returned by send_message or carried on NewsletterMessage). This is not the server_id used by reactions. Empty IDs are rejected.
new_content — Replacement message body. Typically a wa::Message { conversation: Some(..), .. } for text edits.

Example:

use waproto::whatsapp as wa;

let new_body = wa::Message {
    conversation: Some("edited text".to_string()),
    ..Default::default()
};

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

revoke_message

Revoke (delete) a previously-sent newsletter message. Like edit_message, this goes through the plaintext channel path, not the E2E send path.

pub async fn revoke_message(
    &self,
    jid: &Jid,
    message_id: impl Into<String>,
) -> Result<(), NewsletterError>

Parameters:

jid — Newsletter JID. Non-newsletter JIDs are rejected; use Client::revoke_message for DMs and groups.
message_id — The target message’s message_id (wire stanza id, not server_id). Empty IDs are rejected.

Example:

client.newsletter()
    .revoke_message(&newsletter_jid, message_id)
    .await?;

Newsletter JIDs are now also rejected at the root of the E2E send path. If your code accidentally routes a channel JID through send_message_impl, pin_message, or the standard edit_message / revoke_message on Client, you get an error that names the mis-route instead of a malformed encrypted fan-out.

get_messages

Fetch message history from a newsletter.

pub async fn get_messages(
    &self,
    jid: &Jid,
    count: u32,
    before: Option<u64>,
) -> Result<Vec<NewsletterMessage>, NewsletterError>

Parameters:

jid — Newsletter JID
count — Maximum number of messages to return
before — If set, return messages before this server_id (for pagination)

Returns:

Vec<NewsletterMessage> — List of newsletter messages

Example:

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

// Paginate backwards
if let Some(oldest) = messages.last() {
    let older = client.newsletter()
        .get_messages(&newsletter_jid, 50, Some(oldest.server_id))
        .await?;
}

subscribe_live_updates

Subscribe to live updates for a newsletter (reaction counts, message changes).

pub async fn subscribe_live_updates(
    &self,
    jid: &Jid,
) -> Result<u64, NewsletterError>

Parameters:

jid — Newsletter JID

Returns:

u64 — Subscription duration in seconds (typically 300)

The server sends Event::NewsletterLiveUpdate events with updated reaction counts. You need to re-subscribe periodically when the duration expires. Example:

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

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

Types

NewsletterMetadata

Metadata for a newsletter channel. Implements PartialEq and Eq for direct comparison.

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewsletterMetadata {
    pub jid: Jid,
    pub name: String,
    pub description: Option<String>,
    pub subscriber_count: u64,
    pub verification: NewsletterVerification,
    pub state: NewsletterState,
    pub picture_url: Option<String>,
    pub preview_url: Option<String>,
    pub invite_code: Option<String>,
    pub role: Option<NewsletterRole>,
    pub creation_time: Option<u64>,
}

NewsletterVerification

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NewsletterVerification {
    Verified,
    Unverified,
}

NewsletterState

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NewsletterState {
    Active,
    Suspended,
    Geosuspended,
}

NewsletterRole

The viewer’s role in a newsletter.

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NewsletterRole {
    Owner,
    Admin,
    Subscriber,
    Guest,
}

All newsletter enums are #[non_exhaustive], so match statements should include a wildcard arm to handle future variants.

NewsletterAdminProfile

An admin’s public profile within a newsletter, carried on NewsletterAdminInfo and on a NewsletterFollower who is an admin.

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewsletterAdminProfile {
    pub id: Option<String>,
    pub name: String,
    pub picture_id: Option<String>,
    pub picture_direct_path: Option<String>,
}

id is the profile’s own identifier, not a JID — the server hands it back as an opaque string and WhatsApp Web never parses it.

NewsletterAdminInfo

Admin-side information about a newsletter, returned by get_admin_info.

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewsletterAdminInfo {
    pub admin_count: Option<u32>,
    pub admin_profile: Option<NewsletterAdminProfile>,
    pub admin_profiles_enabled: Option<bool>,
}

admin_count — How many admins the newsletter has. The server only answers this for admins and owners, so it’s None for everyone else — never a 0 that would misleadingly read as “no admins”.
admin_profile — The viewer’s own admin profile, present once they’ve set one up.
admin_profiles_enabled — Whether admin profiles are enabled for this newsletter.

NewsletterFollower

A follower (subscriber) of a newsletter, returned by get_followers.

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewsletterFollower {
    pub jid: Jid,
    pub phone_jid: Option<Jid>,
    pub display_name: Option<String>,
    pub username: Option<String>,
    pub role: Option<NewsletterRole>,
    pub follow_time: Option<u64>,
    pub admin_profile: Option<NewsletterAdminProfile>,
}

jid — The follower’s identity JID — a LID on accounts that have migrated.
phone_jid — The follower’s phone-number JID, withheld by the server when the follower’s privacy settings hide it.
role — The follower’s role in the newsletter.
follow_time — When the follower subscribed (Unix seconds).
admin_profile — Set when the follower is an admin who has published a profile.

NewsletterMessage

A message from a newsletter’s history. #[non_exhaustive] — construct it from parsed responses rather than by struct literal, so newly-added counters land as fields, not breaks.

#[non_exhaustive]
pub struct NewsletterMessage {
    pub message_id: String,
    pub server_id: u64,
    pub timestamp: u64,
    pub message_type: NewsletterMessageType,
    pub edit: EditAttribute,
    pub is_sender: bool,
    pub message: Option<wa::Message>,
    pub media_type: Option<NewsletterMediaType>,
    pub reactions: Vec<NewsletterReactionCount>,
    pub votes: Vec<NewsletterPollVote>,
    pub forwards_count: Option<u64>,
    pub views_count: Option<u64>,
    pub responses_count: Option<u64>,
    pub original_timestamp: Option<u64>,
    pub last_edit_timestamp_ms: Option<u64>,
    pub poll_type: Option<PollType>,
    pub content_type: Option<String>,
    pub question_type: Option<NewsletterQuestionType>,
    pub message_association_type: Option<NewsletterMessageAssociationType>,
    pub is_wamo_sub: bool,
    pub admin_profile: Option<NewsletterAdminProfile>,
    pub rcat: Option<Vec<u8>>,
}

message_id — Wire stanza id. Pass this to edit_message and revoke_message; it is not the same as server_id, which reactions use. Empty when the server omitted it.
server_id — Server-assigned monotonic id. Use it as the pagination cursor in get_messages and as the target for send_reaction.
timestamp — Message timestamp (Unix seconds). Moves with an edit.
message_type — Text, Media, or Poll on the wire. An edit or revocation is not a message type; see edit. Reactions are counts on the reacted-to message, not a type.
edit — AdminEdit (3) for an edited message, AdminRevoke (8) for a revoked one, Empty otherwise. A revoked message keeps its envelope, drops its body, its forward counter, and message becomes None.
message — Decoded protobuf message from the <plaintext> bytes. None when the server sent no body (for example, after a revocation, or when the payload was empty).
media_type — Hint about the payload readable without decoding it. Unknown values are kept as NewsletterMediaType::Other.
reactions — Aggregated per-emoji counts.
votes — Per-option tallies when this is a poll message; empty otherwise. See NewsletterPollVote.
forwards_count — How many times the message was forwarded. None means the server omitted the counter; treat it as distinct from Some(0).
views_count, responses_count — View count and channel-question response count. Contract-derived; a follower-side capture never carried them, so expect None unless the viewer’s role in the channel entitles them to those figures.
original_timestamp — <meta original_msg_t> in Unix seconds: when the message was first posted, as opposed to timestamp, which moves with an edit.
last_edit_timestamp_ms — <meta msg_edit_t> in Unix milliseconds (unlike every other timestamp on this struct): when the message was last edited.
poll_type — The poll’s lifecycle stage (creation, quiz creation, result snapshot). Populated only when message_type is Poll, matching WhatsApp Web’s scoping.
content_type, question_type, message_association_type — <meta> classifiers. question_type is question for a channel question or reply for an admin reply. message_association_type records how this media relates to another message (media_poll, motion_photo, poll_add_option, …).
is_wamo_sub — <meta is_wamo_sub="true">.
admin_profile — Publishing admin’s public profile, on channels that enabled admin profiles.
rcat — <rcat> payload bytes. Opaque receiver-side token WhatsApp Web associates with type="media" + mediatype="url" link previews; carried verbatim and not interpreted.

NewsletterMessageType

The type attribute of a newsletter history <message>. Uses a wire enum with an Other(String) fallback so a future value on the wire deserializes rather than fails.

#[non_exhaustive]
pub enum NewsletterMessageType {
    Text,          // "text"
    Media,         // "media"
    Poll,          // "poll"
    Reaction,      // (never emitted; see NewsletterMessage.reactions)
    Revoke,        // (never emitted; a revocation is edit="8")
    PollCreation,  // (never emitted; use Poll + poll_type)
    PollVote,      // (never emitted; use NewsletterMessage.votes)
    Edit,          // (never emitted; an edit is edit="3")
    Other(String),
}

Only Text, Media, and Poll are produced by the wire; the other named variants are kept for source compatibility with earlier releases and will never match a parsed response. Read edits and revocations from NewsletterMessage::edit, poll stage from NewsletterMessage::poll_type, poll totals from NewsletterMessage::votes, and reaction totals from NewsletterMessage::reactions. Methods:

as_str() — Wire-protocol string representation.
From<&str> — Parse from a wire string; unknown values become Other(String).

NewsletterMediaType

The mediatype attribute of newsletter <plaintext>. Known values match the whatspec IR; anything else is kept as Other(String) for forward compatibility.

#[non_exhaustive]
pub enum NewsletterMediaType {
    OnePSticker, Audio, AvatarSticker, CatalogLink, Collection, Document,
    GenAiSticker, Gif, Image, MotionPhoto, MotionVideo, ProductLink,
    Ptt, Ptv, Sticker, StickerPack, Url, UserCreatedSticker, Vcard, Video,
    Other(String),
}

NewsletterQuestionType

The questiontype attribute in newsletter <meta>.

#[non_exhaustive]
pub enum NewsletterQuestionType {
    Question, // "question"
    Reply,    // "reply"
    Other(String),
}

NewsletterMessageAssociationType

The message_association_type attribute in newsletter <meta>. Describes how a media message relates to another message.

#[non_exhaustive]
pub enum NewsletterMessageAssociationType {
    HdImageDualUpload,
    HdVideoDualUpload,
    HevcVideoDualUpload,
    MediaPoll,
    MotionPhoto,
    PollAddOption,
    StickerAnnotation,
    Other(String),
}

NewsletterReactionCount

A reaction count on a newsletter message.

pub struct NewsletterReactionCount {
    pub code: String,
    pub count: u64,
}

NewsletterPollVote

A poll option’s vote tally on a newsletter message. Channel polls are counted server-side, so unlike a DM or group vote the totals arrive in plaintext — nothing to decrypt.

#[non_exhaustive]
pub struct NewsletterPollVote {
    /// SHA-256 of the option name (same digest as `wacore::poll::compute_option_hash`).
    /// Match it against the options of the `pollCreationMessage` in
    /// `NewsletterMessage::message` to recover which option was voted for.
    pub option_hash: [u8; 32],
    /// How many followers picked this option.
    pub count: u64,
}

Votes with malformed hashes or a missing or malformed required count are dropped during parsing; a valid count="0" is preserved and remains distinct from absence.

Error handling

All newsletter methods return Result<T, NewsletterError>:

#[non_exhaustive]
pub enum NewsletterError {
    #[error("{0}")]
    Mex(#[from] MexError),
    #[error("{0}")]
    Iq(#[from] IqError),
    #[error("{0}")]
    Client(#[from] ClientError),
    #[error("invalid newsletter request: {0}")]
    InvalidRequest(String),
    #[error("{0}")]
    Internal(#[from] anyhow::Error),
}

use whatsapp_rust::NewsletterError;

match client.newsletter().join(&newsletter_jid).await {
    Ok(metadata) => println!("Joined: {}", metadata.jid),
    Err(NewsletterError::Mex(e)) => eprintln!("MEX error: {}", e),
    Err(NewsletterError::Iq(e)) => eprintln!("IQ error: {}", e),
    Err(e) => eprintln!("Error: {}", e),
}

​Access

​Methods

​list_subscribed

​get_metadata

​get_metadata_by_invite

​create

​join

​leave

​update

​set_picture

​remove_picture

​delete

​change_owner

​demote_admin

​get_admin_info

​get_followers

​set_follower_mute

​set_admin_mute

​Sending messages

​send_reaction

​edit_message

​revoke_message

​get_messages

​subscribe_live_updates

​Types

​NewsletterMetadata

​NewsletterVerification

​NewsletterState

​NewsletterRole

​NewsletterAdminProfile

​NewsletterAdminInfo

​NewsletterFollower

​NewsletterMessage

​NewsletterMessageType

​NewsletterMediaType

​NewsletterQuestionType

​NewsletterMessageAssociationType

​NewsletterReactionCount

​NewsletterPollVote

​Error handling

Access

Methods

list_subscribed

get_metadata

get_metadata_by_invite

create

join

leave

update

set_picture

remove_picture

delete

change_owner

demote_admin

get_admin_info

get_followers

set_follower_mute

set_admin_mute

Sending messages

send_reaction

edit_message

revoke_message

get_messages

subscribe_live_updates

Types

NewsletterMetadata

NewsletterVerification

NewsletterState

NewsletterRole

NewsletterAdminProfile

NewsletterAdminInfo

NewsletterFollower

NewsletterMessage

NewsletterMessageType

NewsletterMediaType

NewsletterQuestionType

NewsletterMessageAssociationType

NewsletterReactionCount

NewsletterPollVote

Error handling