The Newsletter feature provides methods for managing WhatsApp newsletter channels, including creation, subscription management, 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>, MexError>
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);
}
pub async fn get_metadata(&self, jid: &Jid) -> Result<NewsletterMetadata, MexError>
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);
pub async fn get_metadata_by_invite(
&self,
invite_code: &str,
) -> Result<NewsletterMetadata, MexError>
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, MexError>
name — Newsletter namedescription — 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, MexError>
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<(), MexError>
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, MexError>
jid — Newsletter JIDname — New name, or None to keep the current namedescription — 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);
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?;
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<(), anyhow::Error>
jid — Newsletter JIDserver_id — Server-assigned ID of the message to react toreaction — 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?;
get_messages
Fetch message history from a newsletter.
pub async fn get_messages(
&self,
jid: &Jid,
count: u32,
before: Option<u64>,
) -> Result<Vec<NewsletterMessage>, anyhow::Error>
jid — Newsletter JIDcount — Maximum number of messages to returnbefore — 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, anyhow::Error>
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
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,
}
#[non_exhaustive], so match statements should include a wildcard arm to handle future variants.
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
}
as_str() - Returns the wire-protocol string representationFrom<&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
Metadata and management methods return MexError:
pub enum MexError {
PayloadParsing(String),
// ... other variants
}
send_reaction, get_messages, subscribe_live_updates) return anyhow::Error. Newsletter message sending uses client.send_message() which also returns anyhow::Error.
match client.newsletter().create("Test", None).await {
Ok(metadata) => println!("Created: {}", metadata.name),
Err(e) => eprintln!("Failed: {}", e),
}