• Features
• Why choose this client?
• Quickstart
• Installation
• Configuration
• Usage
• Examples
• API Coverage
• Development
• License

import 'package:anthropic_sdk_dart/anthropic_sdk_dart.dart';

final client = AnthropicClient(
  config: AnthropicConfig(
    authProvider: ApiKeyProvider('YOUR_API_KEY'),
    baseUrl: 'https://api.anthropic.com', // Default
    timeout: Duration(minutes: 5),
    retryPolicy: RetryPolicy(
      maxRetries: 3,
      initialDelay: Duration(seconds: 1),
    ),
  ),
);

Custom base URL (for proxies or testing):

final client = AnthropicClient(
  config: AnthropicConfig(
    baseUrl: 'https://my-proxy.example.com',
    authProvider: ApiKeyProvider('YOUR_API_KEY'),
  ),
);

import 'package:anthropic_sdk_dart/anthropic_sdk_dart.dart';

final client = AnthropicClient.fromEnvironment();

final response = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 1024,
    messages: [
      InputMessage.user('What is the capital of France?'),
    ],
  ),
);

print('Response: ${response.text}');
print('Stop reason: ${response.stopReason}');
print('Usage: ${response.usage.inputTokens} in, ${response.usage.outputTokens} out');

client.close();

final response = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 1024,
    messages: [
      InputMessage.user('My name is Alice.'),
      InputMessage.assistant('Nice to meet you, Alice!'),
      InputMessage.user('What is my name?'),
    ],
  ),
);

print(response.text); // Your name is Alice.

final response = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 1024,
    system: SystemPrompt.text(
      'You are a friendly pirate. Respond in pirate speak.',
    ),
    messages: [
      InputMessage.user('Hello, how are you?'),
    ],
  ),
);

print(response.text); // Ahoy, matey! I be doin' just fine...

import 'dart:io';
import 'package:anthropic_sdk_dart/anthropic_sdk_dart.dart';

final stream = client.messages.createStream(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 256,
    messages: [
      InputMessage.user('Count from 1 to 10 slowly.'),
    ],
  ),
);

await for (final event in stream) {
  if (event is ContentBlockDeltaEvent) {
    final delta = event.delta;
    if (delta is TextDelta) {
      stdout.write(delta.text);
    }
  }
}

Each extension method consumes the stream, so use one per createStream() call:

import 'package:anthropic_sdk_dart/anthropic_sdk_dart.dart';

Stream<MessageStreamEvent> createStream() => client.messages.createStream(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 256,
    messages: [InputMessage.user('Count from 1 to 10 slowly.')],
  ),
);

// Option 1: Collect all text into a single string
final text = await createStream().collectText();

// Option 2: Iterate text deltas as they arrive
await for (final delta in createStream().textDeltas()) {
  stdout.write(delta);
}

// Option 3: Accumulate streaming chunks into a complete Message
await for (final accumulator in createStream().accumulate()) {
  print('Content so far: ${accumulator.text}');
}

// Option 4: Use MessageStreamAccumulator directly for full control
final accumulator = MessageStreamAccumulator();
await for (final event in createStream()) {
  accumulator.add(event);
}
final message = accumulator.toMessage();
print(message.text);

import 'dart:convert';
import 'package:anthropic_sdk_dart/anthropic_sdk_dart.dart';

// Define a tool
final weatherTool = Tool(
  name: 'get_weather',
  description: 'Get the current weather for a location.',
  inputSchema: InputSchema(
    properties: {
      'location': {
        'type': 'string',
        'description': 'City and state, e.g. "San Francisco, CA"',
      },
      'unit': {
        'type': 'string',
        'enum': ['celsius', 'fahrenheit'],
        'description': 'Temperature unit',
      },
    },
    required: ['location'],
  ),
);

// Send message with tool
final response = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 1024,
    tools: [ToolDefinition.custom(weatherTool)],
    messages: [
      InputMessage.user('What is the weather in San Francisco?'),
    ],
  ),
);

// Check if Claude wants to use a tool
if (response.hasToolUse) {
  for (final toolUse in response.toolUseBlocks) {
    print('Tool: ${toolUse.name}');
    print('Input: ${jsonEncode(toolUse.input)}');

    // Execute your tool and send results back...
  }
}

final response = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 16000,
    thinking: ThinkingEnabled(budgetTokens: 10000),
    messages: [
      InputMessage.user('Solve this complex math problem step by step...'),
    ],
  ),
);

// Access thinking blocks
for (final block in response.content) {
  if (block is ThinkingBlock) {
    print('Thinking: ${block.thinking}');
  } else if (block is TextBlock) {
    print('Response: ${block.text}');
  }
}

// Using URL image
final response = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 1024,
    messages: [
      InputMessage.userBlocks([
        const TextInputBlock('What do you see in this image?'),
        const ImageInputBlock(
          UrlImageSource('https://example.com/image.jpg'),
        ),
      ]),
    ],
  ),
);

// Using base64 image
final base64Image = base64Encode(File('image.png').readAsBytesSync());
final response2 = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 1024,
    messages: [
      InputMessage.userBlocks([
        const TextInputBlock('Describe this image.'),
        ImageInputBlock(
          Base64ImageSource(
            mediaType: ImageMediaType.png,
            data: base64Image,
          ),
        ),
      ]),
    ],
  ),
);

// Using URL document
final response = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 1024,
    messages: [
      InputMessage.userBlocks([
        const TextInputBlock('Summarize this PDF document.'),
        const DocumentInputBlock(
          UrlPdfSource('https://example.com/document.pdf'),
        ),
      ]),
    ],
  ),
);

// Using base64 PDF
final base64Pdf = base64Encode(File('document.pdf').readAsBytesSync());
final response2 = await client.messages.create(
  MessageCreateRequest(
    model: 'claude-sonnet-4-20250514',
    maxTokens: 1024,
    messages: [
      InputMessage.userBlocks([
        const TextInputBlock('What are the key points in this document?'),
        DocumentInputBlock(
          Base64PdfSource(base64Pdf),
        ),
      ]),
    ],
  ),
);

// Create a batch
final batch = await client.messages.batches.create(
  MessageBatchCreateRequest(
    requests: [
      BatchRequestItem(
        customId: 'request-1',
        params: MessageCreateRequest(
          model: 'claude-sonnet-4-20250514',
          maxTokens: 100,
          messages: [InputMessage.user('Hello!')],
        ),
      ),
      BatchRequestItem(
        customId: 'request-2',
        params: MessageCreateRequest(
          model: 'claude-sonnet-4-20250514',
          maxTokens: 100,
          messages: [InputMessage.user('How are you?')],
        ),
      ),
    ],
  ),
);

print('Batch ID: ${batch.id}');
print('Status: ${batch.processingStatus}');

// Check batch status
final status = await client.messages.batches.retrieve(batch.id);
print('Progress: ${status.requestCounts.succeeded}/${status.requestCounts.processing}');

// Get results when complete
if (status.processingStatus == ProcessingStatus.ended) {
  await for (final result in client.messages.batches.results(batch.id)) {
    print('${result.customId}: ${result.result}');
  }
}

final response = await client.messages.countTokens(
  TokenCountRequest(
    model: 'claude-sonnet-4-20250514',
    messages: [
      InputMessage.user('Hello, Claude!'),
    ],
  ),
);

print('Input tokens: ${response.inputTokens}');

// List all models
final models = await client.models.list();
for (final model in models.data) {
  print('${model.id}: ${model.displayName}');
}

// Get specific model
final model = await client.models.retrieve('claude-sonnet-4-20250514');
print('Model: ${model.displayName}');
print('Created: ${model.createdAt}');

try {
  final response = await client.messages.create(request);
  print(response.text);
} on AuthenticationException {
  print('Invalid API key - check your credentials');
} on RateLimitException catch (e) {
  print('Rate limited - try again later: ${e.message}');
} on ApiException catch (e) {
  print('API error ${e.statusCode}: ${e.message}');
} on AnthropicException catch (e) {
  print('Anthropic error: ${e.message}');
} catch (e) {
  print('Unexpected error: $e');
}

Exception Hierarchy:

• AnthropicException - Base exception
  • ApiException - API errors with status codes
    • AuthenticationException - 401 errors
    • RateLimitException - 429 errors
  • ValidationException - Client-side validation errors
  • TimeoutException - Request timeouts
  • AbortedException - Request cancellation

import 'dart:async';

final abortController = Completer<void>();

// Start request with abort capability
final requestFuture = client.messages.create(
  request,
  abortTrigger: abortController.future,
);

// Cancel after 5 seconds
Future.delayed(Duration(seconds: 5), () {
  abortController.complete();
});

try {
  final response = await requestFuture;
  print(response.text);
} on AbortedException {
  print('Request was cancelled');
}