ASP.NET Core  

Building AI-Powered Apps with Claude and ASP.NET Core

Artificial intelligence is no longer a futuristic add-on—it’s becoming a standard feature in modern software. With Anthropic’s Claude API, .NET developers can now embed advanced AI capabilities directly into their applications. From intelligent chatbots and document analyzers to enterprise automation tools, Claude makes it possible to deliver smarter user experiences with minimal effort.

In this post, we’ll explore how to integrate Claude AI into an ASP.NET Core project using C#. Along the way, you’ll see how to configure the API, build a service layer, and expose AI functionality through REST endpoints.

Getting Started

Before diving in, make sure you have the following essentials:

  • .NET 8 SDK

  • Visual Studio 2022 or VS Code

  • An Anthropic API key

  • Basic knowledge of ASP.NET Core Web API

  • NuGet Package Manager

Setting Up the Project

Start by creating a new Web API project:

dotnet new webapi -n ClaudeAIIntegration
cd ClaudeAIIntegration
dotnet run

Next, install the required packages:

dotnet add package Microsoft.Extensions.Http
dotnet add package Newtonsoft.Json

Configuring Claude

Add your Claude API settings to appsettings.json:

{
  "ClaudeAI": {
    "ApiKey": "YOUR_API_KEY",
    "BaseUrl": "https://api.anthropic.com/v1/messages",
    "Model": "claude-sonnet-4-0"
  }
}

Then create a simple configuration model:

public class ClaudeSettings
{
    public string ApiKey { get; set; }
    public string BaseUrl { get; set; }
    public string Model { get; set; }
}

Building the Service Layer

The heart of the integration is a service that communicates with Claude.

Here’s a streamlined version:

public class ClaudeService
{
    private readonly HttpClient _httpClient;
    private readonly IConfiguration _configuration;

    public ClaudeService(HttpClient httpClient, IConfiguration configuration)
    {
        _httpClient = httpClient;
        _configuration = configuration;
    }

    public async Task<string> GetResponseAsync(string prompt)
    {
        var apiKey = _configuration["ClaudeAI:ApiKey"];
        var model = _configuration["ClaudeAI:Model"];
        var endpoint = _configuration["ClaudeAI:BaseUrl"];

        _httpClient.DefaultRequestHeaders.Clear();
        _httpClient.DefaultRequestHeaders.Add("x-api-key", apiKey);
        _httpClient.DefaultRequestHeaders.Add("anthropic-version", "2023-06-01");

        var requestBody = new
        {
            model,
            max_tokens = 1024,
            messages = new[] { new { role = "user", content = prompt } }
        };

        var json = JsonConvert.SerializeObject(requestBody);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync(endpoint, content);
        response.EnsureSuccessStatusCode();

        return await response.Content.ReadAsStringAsync();
    }
}

Register the service in Program.cs:

builder.Services.AddHttpClient();
builder.Services.AddScoped<ClaudeService>();

Exposing the API

Create a controller to handle requests:

[ApiController]
[Route("api/[controller]")]
public class ClaudeController : ControllerBase
{
    private readonly ClaudeService _claudeService;

    public ClaudeController(ClaudeService claudeService)
    {
        _claudeService = claudeService;
    }

    [HttpPost]
    public async Task<IActionResult> Ask(ClaudeRequest request)
    {
        var result = await _claudeService.GetResponseAsync(request.Prompt);
        return Ok(result);
    }
}

Now you can send a POST request like:

{
  "prompt": "Explain dependency injection in .NET"
}

And receive a structured AI-generated response.

Production Considerations

To make your integration robust:

  • Secure API keys with tools like Azure Key Vault or AWS Secrets Manager.

  • Rate limit requests to prevent abuse.

  • Log and monitor with Serilog, Application Insights, or OpenTelemetry.

  • Cache responses to reduce costs for repeated queries.

Real-World Applications

Claude AI opens up a wide range of possibilities:

  • AI chatbots for customer support

  • Document analysis for contracts and reports

  • Knowledge base search with vector databases

  • Content generation for technical documentation

  • Enterprise assistants for internal knowledge access

Summary

Claude AI can be integrated into ASP.NET Core applications using a simple service layer built around HttpClient. By configuring API settings, creating a reusable service, and exposing functionality through Web API endpoints, developers can add AI-powered capabilities to their applications quickly and efficiently. With proper security, monitoring, and scalability practices, this approach can be extended to build chatbots, document processing systems, enterprise assistants, and other intelligent solutions.

Membership not found