MisarMisar Docs
MisarMailMisarBlogMisarReachMisarPostMisarDevMisarCoderMisarSEOMisar PlatformMisar SSO
SDKs

Rust SDK

Install and use the MisarMail Rust SDK

Installation

Add to Cargo.toml:

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

Quick Start

use misarmail::Client;
use serde_json::json;

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

    let result = client
        .email
        .send(json!({
            "from": { "email": "hello@misar.io", "name": "Misar" },
            "to": [{ "email": "user@example.com" }],
            "subject": "Welcome",
            "html": "<p>Hello from MisarMail!</p>",
        }))
        .await?;

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

Available Methods

MethodDescription
client.email.send(payload).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(payload).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(json!({
    "url": "https://yourapp.com/webhooks/mail",
    "events": ["email.delivered", "email.opened"],
})).await?;
client.webhooks().test(wh["id"].as_str().unwrap()).await?;

Error Handling

use misarmail::MisarMailError;

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

C# SDK

Install and use the MisarMail C# SDK

Dart SDK

Install and use the MisarMail Dart SDK

On this page

InstallationQuick StartAvailable MethodsExamplesWebhooksError Handling