Misar Docs
MisarMailMisar.BlogMisarReachMisarPostMisar.DevMisar PlatformMisar IdentityMisar Posts API
Sdks

Rust SDK

Install and use the MisarMail Rust SDK

Installation

Add to Cargo.toml:

[dependencies]
misarmail = "0.1"
tokio = { version = "1", features = ["full"] }

Quick Start

use misarmail::{Client, types::{SendRequest, Address}};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(std::env::var("MISARMAIL_API_KEY")?);

    let result = client
        .send(SendRequest {
            from: Address { email: "[email protected]".into(), name: Some("Misar".into()) },
            to: vec![Address { email: "[email protected]".into(), name: None }],
            subject: "Welcome".into(),
            html: Some("<p>Hello from MisarMail!</p>".into()),
            ..Default::default()
        })
        .await?;

    println!("Sent: {}", result.message_id);
    Ok(())
}

Available Methods

MethodDescription
client.send(req).awaitSend a transactional email
client.contacts().list(params).awaitList contacts
client.contacts().create(req).awaitCreate a contact
client.contacts().get(id).awaitGet a contact
client.contacts().update(id, req).awaitUpdate a contact
client.contacts().delete(id).awaitDelete a contact
client.contacts().import_contacts(req).awaitBulk import/upsert contacts
client.campaigns().list(params).awaitList campaigns
client.campaigns().create(req).awaitCreate a campaign
client.campaigns().get(id).awaitGet a campaign
client.campaigns().update(id, req).awaitUpdate a campaign
client.campaigns().send(id).awaitSend/schedule a campaign
client.campaigns().delete(id).awaitDelete a campaign
client.templates().list(params).awaitList templates
client.templates().create(req).awaitCreate a template
client.templates().get(id).awaitGet a template
client.templates().update(id, req).awaitUpdate a template
client.templates().delete(id).awaitDelete a template
client.templates().render(id, req).awaitRender a template with merge data
client.automations().list(params).awaitList automations
client.automations().create(req).awaitCreate an automation
client.automations().get(id).awaitGet an automation
client.automations().update(id, req).awaitUpdate an automation
client.automations().delete(id).awaitDelete an automation
client.automations().activate(id).awaitActivate/deactivate an automation
client.domains().list().awaitList sending domains
client.domains().create(req).awaitAdd a sending domain
client.domains().get(id).awaitGet a domain
client.domains().verify(id).awaitTrigger domain DNS verification
client.domains().delete(id).awaitDelete a domain
client.aliases().list(params).awaitList email aliases
client.aliases().create(req).awaitCreate an alias
client.aliases().get(id).awaitGet an alias
client.aliases().update(id, req).awaitUpdate an alias
client.aliases().delete(id).awaitDelete an alias
client.dedicated_ips().list().awaitList dedicated IPs
client.dedicated_ips().create(req).awaitPurchase a dedicated IP
client.dedicated_ips().update(id, req).awaitUpdate IP pool assignment
client.dedicated_ips().delete(id).awaitRelease a dedicated IP
client.ab_tests().list(params).awaitList A/B tests
client.ab_tests().create(req).awaitCreate an A/B test
client.ab_tests().get(id).awaitGet an A/B test
client.ab_tests().set_winner(id, variant).awaitManually set the winning variant
client.sandbox().send(req).awaitSend in sandbox mode
client.sandbox().list(params).awaitList sandbox messages
client.sandbox().delete(id).awaitDelete a sandbox message
client.inbound().list(params).awaitList inbound routing rules
client.inbound().create(req).awaitCreate an inbound route
client.inbound().get(id).awaitGet an inbound route
client.inbound().delete(id).awaitDelete an inbound route
client.analytics().overview(params).awaitGet send/open/click/bounce analytics
client.track().event(req).awaitTrack a custom event
client.track().purchase(req).awaitTrack a purchase event
client.keys().list().awaitList API keys
client.keys().create(req).awaitCreate an API key
client.keys().get(id).awaitGet an API key
client.keys().revoke(id).awaitRevoke an API key
client.validate().email(address).awaitValidate an email address
client.webhooks().list(params).awaitList webhooks
client.webhooks().create(req).awaitCreate a webhook endpoint
client.webhooks().get(id).awaitGet a webhook
client.webhooks().update(id, req).awaitUpdate a webhook
client.webhooks().delete(id).awaitDelete a webhook
client.webhooks().test(id).awaitSend a test event to a webhook
client.usage().get(params).awaitGet API usage stats
client.billing().subscription().awaitGet current subscription details
client.billing().checkout(req).awaitCreate a billing checkout session
client.workspaces().list().awaitList workspaces
client.workspaces().create(req).awaitCreate a workspace
client.workspaces().get(id).awaitGet a workspace
client.workspaces().update(id, req).awaitUpdate a workspace
client.workspaces().delete(id).awaitDelete a workspace
client.workspaces().list_members(id).awaitList workspace members
client.workspaces().invite_member(id, req).awaitInvite a member to workspace
client.workspaces().update_member(id, user_id, req).awaitUpdate member role
client.workspaces().remove_member(id, user_id).awaitRemove a member from workspace

Examples

Webhooks

let wh = client.webhooks().create(CreateWebhookRequest {
    url: "https://yourapp.com/webhooks/mail".into(),
    events: vec!["email.delivered".into(), "email.opened".into()],
}).await?;
client.webhooks().test(&wh.id).await?;

Error Handling

use misarmail::Error;

match client.send(req).await {
    Ok(r) => println!("Sent: {}", r.message_id),
    Err(Error::Api { status, message }) => eprintln!("API {status}: {message}"),
    Err(e) => eprintln!("Network error: {e}"),
}

C# SDK

Previous Page

Dart SDK

Next Page