DEV Community

Cover image for Kaufland.SellerApi Unleashed: Build Marketplace Integrations in Minutes with .NET 8
Arvind
Arvind

Posted on

Kaufland.SellerApi Unleashed: Build Marketplace Integrations in Minutes with .NET 8

#opensource #webdev #dotnet #csharp

TL;DR: Kaufland.SellerApi is a modern, open-source C# SDK built for .NET 8 that wraps all 24 Kaufland Marketplace Seller API endpoints. It handles HMAC-SHA256 request signing automatically, ships with built-in HTTP resilience, and plugs directly into the .NET Dependency Injection system — so you can skip the plumbing and go straight to building.

Introduction

In the competitive world of e-commerce, speed to market is everything. If you're a .NET developer tasked with integrating a seller's catalog, inventory, or orders with Kaufland — one of Europe's leading online marketplaces — you've likely stared at their OpenAPI documentation and wondered about the best way to handle HMAC signatures, rate limits, and DTO mapping.

Enter the Kaufland Seller API SDK for .NET.

In this post, we're going to dive deep into how you can leverage this modern, community-driven SDK to build a robust integration in minutes rather than weeks. Whether you're managing thousands of SKUs or automating order fulfillment, this guide will get you up and running with best practices firmly in mind.

Why Bother with a Wrapper SDK?

If you've ever tried to integrate a marketplace API from scratch, you know the drill. Before you can write a single line of business logic, you're already deep in the weeds: constructing HMAC signatures, managing Unix timestamps, handling HTTP 429 rate-limit responses, wiring up retries, and massaging raw JSON into usable objects.

The Kaufland Marketplace Seller API v2 is no different. It's a capable, well-documented API — but integrating it directly in a .NET project means dealing with all of that ceremony yourself. Every request must carry a Shop-Signature header computed via HMAC-SHA256, a matching Shop-Timestamp, and a Shop-Client-Key. Get any of it wrong and you get a 401. Get the timestamp stale and you get another 401.

That's exactly the problem the Kaufland.SellerApi SDK solves. It's a community-driven, open-source, strongly-typed C# wrapper built natively for .NET 8. It handles all of the authentication, resilience, and HTTP infrastructure so you can focus entirely on what your application actually needs to do.

Disclaimer: This is a community SDK and is not officially affiliated with, endorsed by, or maintained by Kaufland or Schwarz Gruppe. All trademarks and product names belong to their respective owners.

Let's walk through everything you need to go from zero to making authenticated, production-ready calls against the Kaufland Seller API.

What Makes This SDK Different?

A lot of API wrappers are thin convenience layers — they handle JSON deserialization but leave authentication, retries, and error handling entirely to you. This SDK takes a more opinionated stance, and that's a good thing. Here's what sets it apart:

Native .NET 8. The SDK is built on System.Text.Json and the native HttpClientFactory pattern. There are no legacy third-party HTTP libraries in the dependency chain, which means a leaner dependency graph, better performance, and no compatibility headaches with modern .NET projects.

Built-in resilience. The SDK ships with Microsoft.Extensions.Http.Resilience pre-wired. That means standard HTTP retries and automatic handling of HTTP 429 (rate limit) responses come out of the box. You don't need to bolt on Polly yourself.

Zero-friction authentication. The KauflandAuthenticationHandler intercepts every outgoing request and computes the Shop-Signature HMAC-SHA256 automatically. You configure your keys once at startup and never touch them again.

Complete API coverage. All 24 Kaufland API endpoint domains are supported: Orders, Tickets, Products, Returns, Buybox, Carriers, Warehouses, and more.

Dependency Injection ready. A clean AddKauflandSellerApi() extension method on IServiceCollection wires up the entire SDK in a single call. This is the idiomatic way to register HTTP clients in .NET — the SDK fully embraces it.

Strongly typed DTOs. The data transfer objects are generated from Kaufland's official OpenAPI specification via NSwag, so you get type safety that mirrors the actual API contract.

Prerequisites

Before you start, make sure you have:

  • .NET 8 SDK installed (download here)

  • A Kaufland Seller account with API access enabled

  • Your Client Key and Secret Key from the Kaufland Seller Portal

  • Visual Studio 2026, JetBrains Rider, or the .NET CLI

To get your API credentials, log into your Kaufland Seller account and navigate to Settings → API Access. Generate a new key pair and keep the Secret Key safe — you won't be able to retrieve it again.

Step 1: Install the Package

The SDK is distributed as two packages. The core library is Kaufland.SellerApi, but for most applications you'll want the DI extension package that handles all the wiring:

Via Package Manager Console:

Install-Package Kaufland.SellerApi.Extensions.DependencyInjection
Enter fullscreen mode Exit fullscreen mode

Via .NET CLI:

dotnet add package Kaufland.SellerApi.Extensions.DependencyInjection
Enter fullscreen mode Exit fullscreen mode

This single package pulls in both Kaufland.SellerApi.Core (interfaces, models, contracts) and Kaufland.SellerApi (concrete HTTP client implementations) as transitive dependencies.

Step 2: Register the SDK in Your Application

Open your Program.cs and call AddKauflandSellerApi() on the service collection. This registers the root IKauflandSellerApiClient and all sub-domain HTTP clients into the DI container in one shot.

using Kaufland.SellerApi.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddKauflandSellerApi(options =>
{
    options.ClientKey = builder.Configuration["Kaufland:ClientKey"]!;
    options.SecretKey = builder.Configuration["Kaufland:SecretKey"]!;
});

var app = builder.Build();
app.Run();
Enter fullscreen mode Exit fullscreen mode

One important note: load your keys from configuration, never hardcode them in source. In development, use dotnet user-secrets; in production, use AWS Secrets Manager, Azure Key Vault, or whichever secrets provider you're already running.

# Store keys locally during development
dotnet user-secrets set "Kaufland:ClientKey" "your-client-key"
dotnet user-secrets set "Kaufland:SecretKey" "your-secret-key"
Enter fullscreen mode Exit fullscreen mode

Step 3: Inject and Start Using the Client

Once registered, inject IKauflandSellerApiClient wherever you need it — a background service, a controller, a domain service. The root client exposes every supported API domain as a property, so navigation is intuitive.

Here's a complete service class that fetches new orders and checks API health:

using Kaufland.SellerApi.Core.Clients;

public class OrderProcessingService
{
    private readonly IKauflandSellerApiClient _kaufland;

    public OrderProcessingService(IKauflandSellerApiClient kaufland)
    {
        _kaufland = kaufland;
    }

    public async Task FetchNewOrdersAsync()
    {
        // Fetch up to 100 orders from the marketplace
        var orders = await _kaufland.Orders.GetOrdersAsync(limit: 100);

        foreach (var order in orders.Data)
        {
            Console.WriteLine($"Order ID: {order.Id_order}");
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Notice the pattern: _kaufland.{Domain}.{Method}(). Every domain supported by the Kaufland API is a property on the root client. _kaufland.Orders, _kaufland.Products, _kaufland.Returns, _kaufland.Tickets — they're all there, fully typed, with IDE autocompletion.

What API Domains Are Covered?

The SDK provides complete coverage across all major feature areas of the Kaufland Seller API. Here's a breakdown by category:

Order Management — Orders, Order Units, and Order Invoices. This is where you fetch new orders, accept them, send tracking information after shipping, and handle cancellations.

Product & Inventory — Products, Product Data, Categories, Attributes, and Variant Suggestions. Use these to search the Kaufland catalog, manage your listings, and work with product attributes across categories.

Import/Export Feeds — Import Files for bulk inventory updates, product data imports, and order exports. If you're managing thousands of SKUs, these async feed endpoints are the right tool rather than individual REST calls.

Performance & Insights — Buybox and Assortment Insights. The Buybox data lets you see whether your listings are winning the primary buy placement, which is critical for competitive pricing strategies.

Logistics & Returns — Carriers, Shipping Groups, Warehouses, Returns, and Return Units. This covers the full post-purchase workflow including return authorisation and warehouse management.

Customer Service — Tickets. Handle buyer queries and support messages directly through the API.

Misc — Info (VAT rates, locale data) and Status (the ping endpoint you saw above).

That's 24 endpoint domains in total, all accessible through the single IKauflandSellerApiClient interface.

A Real-World Workflow: Processing Orders End to End

Let's put several of these together into a realistic order-processing workflow. In production, you'd typically run something like this as a BackgroundService on a timer.

public async Task ProcessPendingOrdersAsync()
{
    // 1. Fetch orders that need to be shipped
    var response = await _kaufland.OrderUnits.GetOrderUnitsAsync(
        status: "need_to_be_shipped",
        limit: 50
    );

    foreach (var orderUnit in response.Data)
    {
        try
        {
            // 2. Accept the order unit (signals intent to fulfil)
            await _kaufland.OrderUnits.AcceptOrderUnitAsync(orderUnit.Id_order_unit);

            // 3. After physical shipment, send tracking info
            await _kaufland.OrderUnits.SendOrderUnitAsync(
                idOrderUnit    : orderUnit.Id_order_unit,
                trackingNumber : "JD014600006960000001",
                carrierCode    : "dhl"
            );

            Console.WriteLine($"Fulfilled order unit {orderUnit.Id_order_unit}");
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Failed on {orderUnit.Id_order_unit}: {ex.Message}");
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

This is a pattern you'll use daily if you're running a high-volume Kaufland seller operation. The SDK's built-in resilience handles transient network errors and rate limits transparently — if the API returns a 429, the SDK backs off and retries automatically rather than blowing up with an exception.

Project Architecture: Clean and Contributor-Friendly

If you want to explore or contribute to the SDK, the repository follows Clean Architecture principles with a well-separated project structure:

  • Kaufland.SellerApi.Core — Interfaces, options, generic models (DTOs), and core contracts. Zero implementation details here, making it easy to mock in unit tests.

  • Kaufland.SellerApi — Concrete HTTP client implementations and the KauflandAuthenticationHandler that signs every outgoing request.

  • Kaufland.SellerApi.Extensions.DependencyInjection — The AddKauflandSellerApi() extension and all the IServiceCollection wiring for the .NET Generic Host.

  • Kaufland.SellerApi.ConsoleTests — A sandbox console app for quick manual verification during development.

  • Kaufland.SellerApi.Tests / Kaufland.SellerApi.IntegrationTests — Unit and integration test projects.

This separation means you can mock IKauflandSellerApiClient in your own application's unit tests without any HTTP calls whatsoever — just swap in a mock of the interface using Moq or NSubstitute.

Contributing to the SDK

The project is MIT-licensed and actively welcomes contributions — bug reports, feature requests, new endpoint support, or documentation improvements.

The workflow follows the standard GitHub fork-and-PR model:

  1. Fork the repository and create a feature branch: git checkout -b feature/your-feature

  2. Make your changes, ensuring the existing tests in Kaufland.SellerApi.Tests and Kaufland.SellerApi.IntegrationTests still pass

  3. Commit with a descriptive message: git commit -m 'Add support for XYZ endpoint'

  4. Push and open a Pull Request against main

If you're unsure about scope or design before writing code, open a GitHub Discussion first. It's always better to align early than to have a PR sit unreviewed.

For professional support or custom integration work, the maintainer can be reached at arvind.maurya@gmail.com.

Conclusion

The Kaufland Seller API is genuinely powerful, but integrating it directly in .NET has historically meant a significant amount of undifferentiated heavy lifting before you could ship anything useful. Kaufland.SellerApi removes all of that friction.

In this guide, you installed the package, registered the SDK with a single AddKauflandSellerApi() call, injected IKauflandSellerApiClient into a service class, and explored the full breadth of what the 24 supported API domains let you do. You've also seen how the built-in resilience and Clean Architecture project structure make this a production-ready foundation rather than a weekend hobby project.

Whether you're automating order processing, building a repricing engine that monitors Buybox data, syncing inventory from your warehouse system, or managing customer support tickets programmatically — this SDK gives you a clean, idiomatic .NET 8 starting point backed by an open-source community.

Go ship something. 🚀

Resources

If this post saved you time, share it with a fellow .NET developer working on marketplace integrations. Follow along for more posts on C# SDK design, open-source engineering, and e-commerce automation.

Top comments (0)