Skip to main content

​
Notifications API Guide

Learn how to create and manage notifications using the Wacht Rust SDK.

​
Prerequisites

Before using any API methods, you must initialize the SDK: 
use wacht::WachtClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the client with an API key
    let client = WachtClient::new("wk_live_...");

    // Now you can use the API
    Ok(())
}

​
Create Notification

Send a notification to a specific user.

​
Basic Notification

use wacht::WachtClient;
use wacht::models::CreateNotificationRequest;

let client = WachtClient::new("wk_live_...");

let notification = client.notifications().create(
    CreateNotificationRequest::new(
        "user_123".to_string(),
        "Welcome to Wacht!".to_string(),
        "Your account has been successfully created.".to_string()
    )
)
.send()
.await?;

println!("Created notification: {}", notification.id);

​
Notification with Action Button

use wacht::WachtClient;
use wacht::models::CreateNotificationRequest;

let client = WachtClient::new("wk_live_...");

let notification = client.notifications().create(
    CreateNotificationRequest::new(
        "user_123".to_string(),
        "New Feature Available".to_string(),
        "Check out our latest features.".to_string()
    )
    .with_action("https://example.com/features".to_string(), Some("View Features".to_string()))
)
.send()
.await?;

​
Notification with Severity

use wacht::WachtClient;
use wacht::models::{CreateNotificationRequest, NotificationSeverity};

let client = WachtClient::new("wk_live_...");

let notification = client.notifications().create(
    CreateNotificationRequest::new(
        "user_123".to_string(),
        "Security Alert".to_string(),
        "New sign-in detected from unknown device.".to_string()
    )
    .with_severity(NotificationSeverity::Warning)
)
.send()
.await?;

​
Notification with Metadata and Expiry

use wacht::WachtClient;
use wacht::models::CreateNotificationRequest;
use std::collections::HashMap;

let client = WachtClient::new("wk_live_...");

let mut metadata = HashMap::new();
metadata.insert("category".to_string(), serde_json::json!("security"));
metadata.insert("priority".to_string(), serde_json::json!("high"));

let notification = client.notifications().create(
    CreateNotificationRequest::new(
        "user_123".to_string(),
        "Important Update".to_string(),
        "Please review your account settings.".to_string()
    )
    .with_metadata(metadata)
    .with_expires_hours(24)
)
.send()
.await?;

​
Notification with Custom CTAs

use wacht::WachtClient;
use wacht::models::{CreateNotificationRequest, CallToAction};

let client = WachtClient::new("wk_live_...");

let notification = client.notifications().create(
    CreateNotificationRequest::new(
        "user_123".to_string(),
        "Complete Your Profile".to_string(),
        "Add more details to your profile.".to_string()
    )
    .with_ctas(vec![
        CallToAction {
            label: "Complete Profile".to_string(),
            url: "https://example.com/profile".to_string(),
            primary: true,
        },
        CallToAction {
            label: "Skip".to_string(),
            url: "https://example.com/dashboard".to_string(),
            primary: false,
        },
    ])
)
.send()
.await?;
​
request
CreateNotificationRequest
required

​
Severity Levels

Notifications support four severity levels via NotificationSeverity: 
use wacht::models::NotificationSeverity;

NotificationSeverity::Info     // General information
NotificationSeverity::Success  // Success confirmation
NotificationSeverity::Warning  // Warning alerts
NotificationSeverity::Error    // Error notifications

​
CallToAction Structure

For custom CTAs, use the CallToAction struct: 
use wacht::models::CallToAction;

CallToAction {
    label: "View Details".to_string(),
    url: "https://example.com/details".to_string(),
    primary: true,  // Whether this is the primary action
}

​
Error Handling

All SDK methods return a Result<T, Error>: 
use wacht::{Error, WachtClient};
use wacht::models::CreateNotificationRequest;

let client = WachtClient::new("wk_live_...");

match client.notifications().create(
    CreateNotificationRequest::new(
        "invalid_user".to_string(),
        "Test".to_string(),
        "Test message".to_string()
    )
).send().await {
    Ok(notification) => println!("Created: {}", notification.id),
    Err(Error::Api { status, message, .. }) => {
        eprintln!("API Error {}: {}", status, message);
    }
    Err(Error::Request(e)) => {
        eprintln!("Network error: {}", e);
    }
    Err(e) => {
        eprintln!("Other error: {}", e);
    }
}