Add E-Signatures to Rust (Axum)

Quick start

1. Get an API key from signb.ee (free, no credit card)
2. Set SIGNBEE_API_KEY in your environment
3. Add the code below to your app

Rust (Axum) example

use axum::{Json, extract::State};
use reqwest::Client;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct ContractReq {
    content: String,
    sender_name: String,
    sender_email: String,
    recipient_name: String,
    recipient_email: String,
}

async fn send_contract(
    State(client): State<Client>,
    Json(req): Json<ContractReq>,
) -> Json<serde_json::Value> {
    let res = client.post("https://signb.ee/api/send")
        .bearer_auth(std::env::var("SIGNBEE_API_KEY").unwrap())
        .json(&req)
        .send().await.unwrap();
    Json(res.json().await.unwrap())
}

What happens

1. Your app sends markdown or a PDF URL to Signbee
2. Signbee generates a PDF (if markdown) and emails the recipient a signing link
3. Recipient signs — both parties receive the signed PDF with SHA-256 certificate

Also works with AI agents

Install the MCP server to let Claude, Cursor, or Windsurf send documents directly:

npx -y signbee-mcp

Integration details

Rust with Axum is the highest-performance option for e-signature integration. Axum's async-first design and Rust's zero-cost abstractions make it ideal for services handling thousands of concurrent signing requests.

Axum + Reqwest: The example uses Axum for the web framework and reqwest for the HTTP client. Both are async-native and integrate with Tokio, Rust's async runtime. The reqwest::Client should be shared (via Axum's State extractor) to enable connection pooling.

Type safety: Rust's type system ensures contract requests are validated at compile time. The ContractReq struct with serde derives provides automatic JSON serialisation/deserialisation with compile-time guarantees. No runtime validation code needed.

Error handling: Replace .unwrap() with proper error handling in production. Use Axum's IntoResponse trait with custom error types, or the anyhow crate for ergonomic error propagation. Return appropriate HTTP status codes (400, 401, 500) for different failure modes.

Tower middleware: Axum is built on Tower, which provides composable middleware. Add rate limiting (tower::limit), request tracing (tower_http::trace), timeouts (tower::timeout), and authentication as middleware layers.

Docker deployment: Rust binaries are statically compiled. Use a multi-stage Docker build — compile in a rust:slim builder stage, then copy the binary to a minimal base image (scratch or distroless). The final image is typically under 20MB.

FAQs