Struct ClaudeClient 

pub struct ClaudeClient { /* private fields */ }

Claude API client

This client can connect to either the Anthropic API directly or AWS Bedrock.

Example - Anthropic API

use claude_sdk::ClaudeClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = ClaudeClient::anthropic(
        std::env::var("ANTHROPIC_API_KEY")?
    );
    Ok(())
}

Example - AWS Bedrock

use claude_sdk::ClaudeClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Requires --features bedrock
    let client = ClaudeClient::bedrock("us-east-1").await?;
    Ok(())
}

Implementations

impl ClaudeClient

pub fn anthropic(api_key: impl Into<String>) -> Self

Create a new client for the Anthropic API

Example

use claude_sdk::ClaudeClient;

let client = ClaudeClient::anthropic("your-api-key");

pub async fn bedrock(region: impl Into<String>) -> Result<Self>

Create a new client for AWS Bedrock

This loads AWS credentials from the environment (AWS_PROFILE, AWS_ACCESS_KEY_ID, etc.) using the standard AWS credential chain.

Example

use claude_sdk::ClaudeClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Uses AWS_PROFILE or default credential chain
    let client = ClaudeClient::bedrock("us-east-1").await?;
    Ok(())
}

pub async fn send_message( &self, request: MessagesRequest, ) -> Result<MessagesResponse>

Send a message and get a complete response

This is the non-streaming API. For streaming responses, use send_streaming().

Example

use claude_sdk::{ClaudeClient, MessagesRequest, Message};

let client = ClaudeClient::anthropic("your-api-key");

let request = MessagesRequest::new(
    "claude-3-5-sonnet-20241022",
    1024,
    vec![Message::user("Hello, Claude!")],
);

let response = client.send_message(request).await?;
println!("Response: {:?}", response.content);

pub async fn send_streaming( &self, request: MessagesRequest, ) -> Result<Pin<Box<dyn Stream<Item = Result<StreamEvent>> + Send>>>

Send a message and stream the response

Returns a stream of events as Claude generates its response.

Example

use claude_sdk::{ClaudeClient, MessagesRequest, Message, StreamEvent};
use futures::StreamExt;

let client = ClaudeClient::anthropic("your-api-key");

let request = MessagesRequest::new(
    claude_sdk::models::CLAUDE_SONNET_4_5.anthropic_id,
    1024,
    vec![Message::user("Tell me a story")],
);

let mut stream = client.send_streaming(request).await?;

while let Some(event) = stream.next().await {
    match event? {
        StreamEvent::ContentBlockDelta { delta, .. } => {
            if let Some(text) = delta.text() {
                print!("{}", text);
            }
        }
        StreamEvent::MessageStop => break,
        _ => {}
    }
}

pub async fn count_tokens(&self, request: MessagesRequest) -> Result<TokenCount>

Count tokens for a request without sending it

Uses the server-side token counting endpoint for accurate counts. This is more accurate than the local TokenCounter but requires an API call.

Example

use claude_sdk::{ClaudeClient, MessagesRequest, Message};

let client = ClaudeClient::anthropic("your-api-key");

let request = MessagesRequest::new(
    "claude-sonnet-4-5-20250929",
    1024,
    vec![Message::user("Hello!")],
);

let count = client.count_tokens(request).await?;
println!("Would use {} input tokens", count.input_tokens);

pub async fn send_message_with_retry( &self, request: MessagesRequest, config: RetryConfig, ) -> Result<MessagesResponse>

Send a message with automatic retry on transient failures

This method automatically retries on rate limits (429) and server errors (5xx) using exponential backoff. Use the provided RetryConfig to customize behavior.

Example

use claude_sdk::{ClaudeClient, MessagesRequest, Message};
use claude_sdk::retry::RetryConfig;

let client = ClaudeClient::anthropic("your-api-key");

let request = MessagesRequest::new(
    claude_sdk::models::CLAUDE_SONNET_4_5.anthropic_id,
    1024,
    vec![Message::user("Hello!")],
);

let config = RetryConfig::new().with_max_attempts(5);
let response = client.send_message_with_retry(request, config).await?;

pub async fn send_streaming_with_retry( &self, request: MessagesRequest, config: RetryConfig, ) -> Result<Pin<Box<dyn Stream<Item = Result<StreamEvent>> + Send>>>

Send a streaming message with automatic retry on transient failures

Note: Retries create a new stream, so partial results from failed attempts are lost.