AWS Bedrock with .NET: Getting Started

• AWS account with Bedrock access
• AWS credentials configured via aws configure
• .NET 9 SDK or later
• NuGet packages: AWSSDK.Bedrock, AWSSDK.BedrockRuntime

Run aws configure and enter your credentials. The SDK automatically reads from ~/.aws/credentials:

var bedrockClient = new AmazonBedrockClient(RegionEndpoint.USEast1);
            

• Credentials missing? Check ~/.aws/credentials (or %USERPROFILE%\.aws\credentials on Windows).
• Model not found? Request access in AWS Console → Bedrock → Model access (5–15 min wait).
• Wrong region? Claude 3 Haiku is in us-east-1 and us-west-2 only. Check model availability.
• Package version? Use AWSSDK.BedrockRuntime 3.7.0 or later.

Now that everything is configured and common pitfalls are clear, let's get hands-on and invoke Claude. Here's a real, working example from the ai-playground repository that demonstrates how to build a practical Bedrock application:

public async Task<string> GetMovieDetails(string movieQuery)
{
    // Build the prompt for Claude models: must start with "\n\nHuman: " and end with "\n\nAssistant:"
    var prompt =
        $"\n\nHuman: You are a movie information expert. Provide detailed information about the movie '{movieQuery}'. " +
        "Return the results as a JSON array of objects with the following fields: title (string), year (integer), " +
        "category (string, Movie/TV), directors (array of strings), actors (array of strings), plot (string), genre (string), rating (string). " +
        "If no movie is found, return an empty JSON array.\n\nAssistant:";

    var request = new InvokeModelRequest
    {
        ModelId = "anthropic.claude-3-haiku-20240307-v1:0",
        ContentType = "application/json",
        Accept = "application/json",
        Body = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(
            JsonSerializer.Serialize(new
            {
                anthropic_version = "bedrock-2023-05-31",
                max_tokens = 1024,
                messages = new[]
                {
                    new { role = "user", content = prompt }
                }
            })
        ))
    };

    var response = await _client.InvokeModelAsync(request);
    var responseBody = System.Text.Encoding.UTF8.GetString(response.Body.ToArray());
    return FormatJsonString(responseBody);
}
                

What's happening:

• You craft a structured prompt that tells Claude exactly what format to return (JSON with specific fields).
• You create an InvokeModelRequest with your model ID and serialized prompt.
• The SDK sends the request to Bedrock. Claude processes it and returns structured movie data as JSON.
• You parse the response and return it to the caller.

This example shows why Bedrock is powerful: one unified C# API to get smart, JSON-formatted responses from Claude. Users can add similar methods for classification, summarization, extraction, or chat—all using the same pattern.

For scale, batch requests using Task.WhenAll. With 10,000 items at 1-2 seconds each, sequential processing takes 3–6 hours; batching (size 10–20) reduces this to ~15 minutes.

• Batch size: Start with 10–20, tune based on throttling. Us-east-1 allows higher throughput.
• Error handling: Implement exponential backoff for throttling. Queue failed items for async retry.
• Idempotency keys: Include item IDs or timestamps to prevent re-processing on retries.

Claude 3 Haiku/Sonnet are in us-east-1 and us-west-2. Titan Text is more widely available. ModelNotFound errors are usually region mismatches—always check region first.

Bedrock enforces account-specific quotas to protect infrastructure. The default is commonly around 100 requests per minute per model, though this varies by region, account age, and model. Exceed your quota and you'll get a ThrottlingException. In production, implement exponential backoff and request a higher quota from AWS Support if needed.

Pricing impact: Bedrock charges per input + output token. A 1000-ticket batch can run approximately $5–20 depending on model and verbosity (check current pricing for exact rates). Always estimate costs before scaling.

Claude 3 models have different characteristics. Note: Pricing and latency figures change frequently. Check the AWS Bedrock pricing page for current rates:

• Haiku (fastest, cheapest): Best for simple tasks like classification and extraction. Lowest latency.
• Sonnet (balanced): Better reasoning than Haiku. Mid-range cost and latency. Suitable for most applications.
• Opus (most capable, if available): Check AWS docs—may not be available in all regions or via Bedrock.
• Token limits vary: Check the model documentation for current context window sizes.