Struct Chat 

pub struct Chat {

    pub id: String,
    pub local_chat_id: Option<String>,
    pub account_id: String,
    pub network: String,
    pub title: String,
    pub chat_type: String,
    pub participants: Participants,
    pub last_activity: Option<String>,
    pub unread_count: u32,
    pub last_read_message_sort_key: Option<u64>,
    pub is_archived: bool,
    pub is_muted: bool,
    pub is_pinned: bool,
    pub preview: Option<Box<Message>>,
}

A chat or conversation

Fields

id: String

Unique chat ID

local_chat_id: Option<String>

Local chat ID specific to this Beeper Desktop installation

account_id: String

Account ID this chat belongs to, generaly “whatsapp” etc.

network: String

Display-only human-readable network name (e.g., ‘WhatsApp’, ‘Messenger’)

title: String

Display title of the chat

chat_type: String

Chat type: ‘single’ for direct messages, ‘group’ for group chats

participants: Participants

Chat participants information

last_activity: Option<String>

Timestamp of last activity

unread_count: u32

Number of unread messages

last_read_message_sort_key: Option<u64>

Last read message sortKey

is_archived: bool

True if chat is archived

is_muted: bool

True if chat notifications are muted

is_pinned: bool

True if chat is pinned

preview: Option<Box<Message>>

Last message preview for this chat, if available

Implementations

impl Chat

pub fn display_name(&self) -> String

Get a display name for the chat

For direct messages (‘single’), returns the participant’s full name or username. For group chats, returns the chat title.

Examples found in repository

examples/fetch_chats.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example fetch_chats");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats
    println!("📋 Fetching chats from Beeper...");
    let chats_response = client.list_chats(None, None).await?;

    // Extract chat names into a vector using the display_name method
    let chat_names: Vec<String> = chats_response
        .items
        .iter()
        .map(|chat| chat.display_name())
        .collect();

    // Display results
    println!("✅ Successfully retrieved {} chats:", chat_names.len());
    println!();

    if chat_names.is_empty() {
        println!("No chats found.");
    } else {
        for (index, name) in chat_names.iter().enumerate() {
            println!("  {}. {}", index + 1, name);
        }
    }

    println!();
    println!("Chat names as array:");
    println!("{:#?}", chat_names);

    Ok(())
}

Trait Implementations

impl Clone for Chat

fn clone(&self) -> Chat

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Chat

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Chat

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Chat

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.