dt-msgraph

What is dt-msgraph?

dt-msgraph is a Rust SDK (software development kit) for the Microsoft Graph API — the unified API that powers Microsoft 365, Azure Active Directory (Entra ID), Outlook, Teams, SharePoint, OneDrive, Planner, and more. It gives Rust developers a strongly-typed, async-first, production-ready way to authenticate against Microsoft's identity platform and call every major Graph module without writing raw HTTP requests by hand.

It is designed for real production workloads: background daemons processing thousands of mailboxes, serverless functions with cold-start constraints, desktop applications built with Tauri, and enterprise middle-tier APIs that need On-Behalf-Of authentication — not just scripts and demos.

Why Rust for Microsoft Graph?

Traditional Microsoft Graph SDKs in Python, C#, or Node.js carry the overhead of their runtimes: garbage collection pauses, heavier memory footprints, and thread-blocking architectures that show up under real concurrent load. dt-msgraph is built in Rust specifically to avoid all three:

• No Garbage CollectorRust's ownership model means no GC pauses, ever. Response latency stays predictable even under heavy concurrent load, which matters most in exactly the enterprise scenarios (background sync daemons, high-throughput middle-tier APIs) this SDK targets.
• Compiled to Native Machine CodeVia LLVM, dt-msgraph compiles down to native binaries with none of the startup overhead of an interpreted or JIT-compiled runtime.
• Memory Safety Without Manual ManagementRust's borrow checker eliminates entire classes of bugs (use-after-free, data races, null pointer dereferences) at compile time, which matters enormously for code that's handling access tokens and client secrets.

Speed & Performance: dt-msgraph vs Others

How dt-msgraph achieves this:

• 10x Less Memory — runs with a fraction of the memory footprint compared to C# or Java SDKs, making it ideal for serverless functions (AWS Lambda / Azure Functions) or edge deployments where memory is billed by the MB-second.
• Zero-Blocking Concurrency — built on tokio and reqwest. Authentication tokens are managed using tokio::sync::RwLock, allowing thousands of concurrent threads to read tokens simultaneously without ever blocking the executor.
• JSON Batching Optimization — combine up to 20 individual API calls into a single HTTP request using the Graph $batch API, cutting network round-trips and latency dramatically for bulk operations.
• Single & Multi-Threaded Execution — run requests on a single thread for simple scripts and CLIs, or scale out across multiple threads/tasks for high-throughput services — the same client works either way, no separate code paths needed.
• Single & Batch Processing, Both Supported — call one endpoint at a time when that's all a task needs, or batch dozens of calls together when processing bulk data (mailboxes, users, files) — the API is built to support both without forcing a single style.
• No Garbage Collection — predictable, ultra-low-latency response times, which matters most under exactly the sustained concurrent load enterprise Graph integrations tend to run under.

Quick Start

[dependencies]
dt-msgraph = "1.0"
tokio = { version = "1", features = ["full"] }

use dt_msgraph::{GraphClient, ClientCredentials};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = GraphClient::client_credentials(
        "TENANT_ID",
        "CLIENT_ID",
        "CLIENT_SECRET",
    ).await?;

    let users = client
        .users()
        .list()
        .select(&["id", "displayName", "mail"])
        .top(25)
        .send()
        .await?;

    println!("{:#?}", users);
    Ok(())
}

That's a working, production-grade authenticated Graph API call in under 15 lines — with automatic token caching, retry-on-429, and pagination handling included by default.

Write Once, Run Anywhere (Cross-Platform)

Because dt-msgraph is compiled to native machine code via LLVM, it runs on virtually every platform and architecture:

Multi-Language Integration (FFI Ready)

dt-msgraph is written in Rust for maximum safety and performance — but an entire backend doesn't need to be rewritten in Rust to use it. Rust's excellent C-interoperability means this SDK integrates into an existing tech stack:

• C/C++ — compile directly as a shared library (.so, .dll, .dylib) and call it natively.
• Python — use PyO3 to create fast native Python bindings for data science or Django/FastAPI backends that need Graph API access without Python's interpreter overhead on the hot path.
• C# / .NET — integrate via P/Invoke to bring Rust's memory safety and speed into existing .NET enterprise applications.
• Java — call the library directly via JNI (Java Native Interface).
• Node.js — compile to WebAssembly (Wasm) or use Node-API (N-API) for native execution inside JavaScript/TypeScript services.

The performance of Rust, inside whatever language a team already uses.

Core Features (A to Z)

ODataQuery::new()
    .select(&["id", "displayName", "mail"])
    .filter("startswith(displayName, 'A')")
    .top(50)
    .skip_token("next-page-token")

dt-msgraph vs Other Microsoft Graph SDKs

dt-msgraph and graph-rs-sdk are both Rust-native, which already puts them ahead of GC'd-runtime SDKs on memory and latency. Where dt-msgraph goes further is sovereign cloud support, built-in memory-safe secret handling, FFI bindings for non-Rust teams, and a fully built-out On-Behalf-Of flow for middle-tier API scenarios — the pieces that turn a fast HTTP client into something an enterprise security team will actually sign off on.

Who Should Use dt-msgraph?

• Backend/platform engineers building high-throughput services that talk to Microsoft 365 at scale and can't afford GC pauses under load.
• Enterprise security teams that require Managed Identity, sovereign cloud support, or memory-safe secret handling as a baseline, not an afterthought.
• Desktop app developers using Tauri or native toolkits who want a Microsoft Graph client that compiles natively instead of bundling a runtime.
• Polyglot teams who want Rust's performance inside an existing Python, C#, Java, or Node.js codebase via FFI, without a full rewrite.
• DevOps/IT automation engineers writing CLI tools and background daemons against Client Credentials or Device Code flows.

FAQ

Licensing

dt-msgraph is a commercial SDK with a free trial.

• Trial — full SDK, free to use for evaluation but restricted to a maximum of 5 users and 50 items.
• Purchase — buy a license and receive a license file. Use it to activate the SDK (.dll), which removes all limits (unlimited items and users) for full production use.