Claude API Rust Client Library: Options and Setup

If you're searching for a "Claude API Rust client library," here's the direct answer: Anthropic does not publish an official Rust SDK. Official clients exist for Python, TypeScript/JavaScript, and a few others, but Rust isn't on that list as of this writing. That doesn't mean you're stuck — Rust developers call the Claude API all the time, either through a community-maintained crate or by talking to the HTTP endpoint directly with reqwest and serde.

The second thing worth knowing: the Claude API is a plain JSON-over-HTTPS REST API with a predictable request/response shape (the Messages API). That makes it trivial to wrap in Rust yourself, and it's exactly why a hand-rolled client is often more reliable than a half-maintained community crate — you control the dependency, the error handling, and the upgrade path.

Your three options

1. A community crate. Searching crates.io turns up a handful of Claude/Anthropic wrappers (names and maintenance status change often, so check download counts, last-publish date, and open issues before committing). These can save time for simple chat use cases, but they frequently lag behind new features like extended thinking, tool use, or the latest model IDs. If you pick one, pin the version and read the source before trusting it in production — these aren't audited by Anthropic.

2. Roll your own thin client. This is the most common approach among Rust teams using Claude, and it's not much code. You get full control over retries, timeouts, streaming, and how you map errors into your own types.

3. Go through a proxy that normalizes the API. If you're building a product on top of Claude rather than a personal script, a gateway like SubToAPI gives you a stable REST endpoint, generated API keys, usage metadata, and per-seat billing — all without touching your Rust code's HTTP logic, since it mirrors the standard Messages API shape. More on this below.

Building a minimal Rust client with reqwest

Add the dependencies:

[dependencies]
reqwest = { version = "0.12", features = ["json"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }

A basic request/response pair:

use serde::{Deserialize, Serialize};

#[derive(Serialize)]
struct Message {
    role: String,
    content: String,
}

#[derive(Serialize)]
struct MessagesRequest {
    model: String,
    max_tokens: u32,
    messages: Vec<Message>,
}

#[derive(Deserialize, Debug)]
struct MessagesResponse {
    content: Vec<ContentBlock>,
}

#[derive(Deserialize, Debug)]
struct ContentBlock {
    text: Option<String>,
}

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

    let body = MessagesRequest {
        model: "claude-sonnet-4".to_string(),
        max_tokens: 512,
        messages: vec![Message {
            role: "user".to_string(),
            content: "Summarize the Rust ownership model in two sentences.".to_string(),
        }],
    };

    let resp = client
        .post("https://api.subtoapi.app/v1/messages")
        .bearer_auth(api_key)
        .json(&body)
        .send()
        .await?
        .json::<MessagesResponse>()
        .await?;

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

This structure — swap the base URL and the auth header, keep everything else identical — is the same whether you point it at Anthropic directly or at a compatible gateway. That's the point of standardizing on the Messages API shape: your Rust types don't change based on who's issuing the key.

Streaming responses

Claude's streaming uses server-sent events. In Rust, reqwest gives you a byte stream you can decode line-by-line, matching on event: and data: prefixes and parsing each JSON chunk. If you're building a CLI tool or TUI, this is where most of the real engineering effort goes — buffering partial UTF-8, handling content_block_delta events, and stopping cleanly on message_stop. See /docs/streaming for the event format if you're implementing this against SubToAPI's endpoint, since the chunk structure is the same one you'd parse from Anthropic directly.

Tool use and structured output

If your Rust service needs Claude to call functions (database lookups, calculators, internal APIs), you define tool schemas as JSON and parse tool_use content blocks from the response the same way you parse text blocks — just check the type field on each block before deserializing. /docs/tools covers the request/response shape in detail.

Why a gateway matters for a Rust project specifically

Rust is often chosen for backend services that need to be fast, long-running, and cheap to operate — exactly the kind of service where you don't want API key sprawl, missing usage visibility, or per-developer billing headaches. SubToAPI turns your Claude access into an HTTPS API with sub_live_... application keys, so each Rust service or team member gets its own scoped key instead of sharing one raw credential. You still write the same reqwest calls shown above; you just get a dashboard for usage, streaming, tool use, and team seats on top.

Plans run Solo at €9, Team at €19/seat, and Scale at €49/seat, with a free trial at /signup. If you're prototyping a Rust client right now, /docs/quickstart has the fastest path to a working request, and /docs/messages documents the full request/response schema your structs need to match.

Practical recommendation

For a quick script or prototype, grab a community crate and see if it covers your use case — check its last commit date first. For anything going to production, write the thin reqwest-based client above; it's maybe 80 lines of code, it won't break when Anthropic ships a new feature, and you fully understand every request it sends. Either way, point it at an endpoint that gives you proper key management and usage tracking rather than hardcoding a shared secret into your binary.

Questions

Is there an official Anthropic Rust SDK? No. Anthropic publishes official SDKs for Python and TypeScript/JavaScript, not Rust. Rust developers use community crates or call the HTTP API directly.

Can I just use reqwest and serde instead of a dedicated crate? Yes, and for production services this is usually the better choice — you avoid depending on an unmaintained third-party crate and keep full control over retries, timeouts, and error types.

Does streaming work the same way in Rust as in other languages? The underlying protocol (server-sent events with JSON chunks) is identical; you just need to decode the byte stream yourself since Rust has no built-in SSE client in reqwest. See /docs/streaming for the exact event structure.