C# Academy · Lesson

Integrating Validation with APIs

Return clean validation error responses.

Integrating Validation with APIs is a free C# Academy lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the C# Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Wiring FluentValidation Into ASP.NET Core

To validate requests automatically, register your validators with dependency injection. The AddValidatorsFromAssembly helper scans an assembly and registers every validator it finds.

using FluentValidation;

builder.Services
    .AddValidatorsFromAssemblyContaining<CustomerValidator>();

Automatic Validation Middleware

Modern FluentValidation favors explicit validation, but you can enable automatic validation that hooks into model binding so invalid requests are rejected before your action runs.

dotnet add package FluentValidation.AspNetCore

builder.Services.AddFluentValidationAutoValidation();

Validators Resolved From DI

Because validators are registered with DI, they can inject services like repositories, enabling database-backed async rules to work seamlessly in your API.

public class UserValidator : AbstractValidator<UserRequest>
{
    public UserValidator(IUserRepository repo)
    {
        RuleFor(u => u.Email)
            .MustAsync(async (e, ct) => !await repo.ExistsAsync(e));
    }
}

Explicit Validation In An Endpoint

Many teams prefer explicit validation for clarity. Inject IValidator<T> and call it at the top of the handler.

app.MapPost("/users", async (
    UserRequest request,
    IValidator<UserRequest> validator) =>
{
    var result = await validator.ValidateAsync(request);
    if (!result.IsValid)
        return Results.ValidationProblem(result.ToDictionary());
    return Results.Ok();
});

What Is ProblemDetails?

ProblemDetails (RFC 7807) is a standard JSON format for HTTP error responses. It has fields like type, title, status and detail, giving clients a predictable error shape.

{
  "type": "https://tools.ietf.org/html/rfc7231",
  "title": "One or more validation errors occurred.",
  "status": 400,
  "errors": { "Email": ["Email is required."] }
}

ValidationProblemDetails

For validation failures ASP.NET Core uses ValidationProblemDetails, which extends ProblemDetails with an errors dictionary mapping each field to its messages.

return Results.ValidationProblem(result.ToDictionary());
// Produces a 400 ValidationProblemDetails response

Converting FluentValidation Results

The ToDictionary() extension turns a ValidationResult into the field -> messages dictionary that ValidationProblem expects.

var result = await validator.ValidateAsync(request);
if (!result.IsValid)
{
    IDictionary<string, string[]> errors = result.ToDictionary();
    return Results.ValidationProblem(errors);
}

Customizing The ProblemDetails Output

Use AddProblemDetails and a customizer to enrich every error response, for example adding a trace id for debugging.

builder.Services.AddProblemDetails(options =>
{
    options.CustomizeProblemDetails = ctx =>
        ctx.ProblemDetails.Extensions["traceId"] =
            ctx.HttpContext.TraceIdentifier;
});

Validation In MVC Controllers

With auto-validation enabled and [ApiController], controller actions also return ValidationProblemDetails automatically when a request is invalid, so the format is consistent across endpoints.

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    [HttpPost]
    public IActionResult Create(UserRequest request) => Ok();
}

A Validation Filter For Minimal APIs

You can centralize explicit validation with an endpoint filter so each handler stays clean.

app.MapPost("/users", (UserRequest r) => Results.Ok())
   .AddEndpointFilter<ValidationFilter<UserRequest>>();

Choosing Auto vs Explicit

Auto-validation is convenient but hides the validation step; explicit validation is verbose but transparent and easier to test. Many teams pick explicit validation plus a shared filter for the best of both.

Quick Check

Test API validation integration.

Recap

Integrating validation means registering validators with AddValidatorsFromAssembly, optionally enabling auto-validation, and returning errors as ValidationProblemDetails via Results.ValidationProblem(result.ToDictionary()). DI lets validators use repositories for async rules, and you can customize ProblemDetails or use endpoint filters to keep handlers clean.

Frequently asked questions

Is the “Integrating Validation with APIs” lesson free?

Yes — the full text of “Integrating Validation with APIs” is free to read here on the web, and the C# Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the C# Academy course, upgrade to CoddyKit PRO.

What will I learn in “Integrating Validation with APIs”?

Return clean validation error responses. You practise C# Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start C# Academy?

No prior experience is required. C# Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Integrating Validation with APIs” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this C# Academy lesson?

Yes. Every C# Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to C# Academy