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.

pub struct NewsletterMessage {
    /// Server-assigned message ID (monotonic, used for pagination cursors).
    pub server_id: u64,
    /// Message timestamp (Unix seconds).
    pub timestamp: u64,
    /// Message type (Text, Media, Reaction, etc.).
    pub message_type: NewsletterMessageType,
    /// Whether the viewer is the sender.
    pub is_sender: bool,
    /// Decoded protobuf message (from plaintext bytes).
    pub message: Option<wa::Message>,
    /// Reaction counts on this message.
    pub reactions: Vec<NewsletterReactionCount>,
}

NewsletterMessageType

The type of a newsletter message. Uses a StringEnum for type-safe wire-protocol mapping. Implements PartialEq and Eq.

#[non_exhaustive]
pub enum NewsletterMessageType {
    Text,          // "text"
    Media,         // "media"
    Reaction,      // "reaction"
    Revoke,        // "revoke"
    PollCreation,  // "poll_creation"
    PollVote,      // "poll_vote"
    Edit,          // "edit"
    Other(String), // Unknown/future types
}

Methods:

as_str() - Returns the wire-protocol string representation
From<&str> - Parse from wire string, unknown values become Other(String)

NewsletterReactionCount

A reaction count on a newsletter message.

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

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

​NewsletterReactionCount

​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

NewsletterReactionCount

Error handling