Official Linkit SDKs — integrate the Linkit API from any language with production-grade resilience, fluent builders, and type safety.

SDK Reference

Linkit provides official SDKs for 10 languages across 11 packages. Every SDK implements the same architecture: typed models, fluent builders or transport-first service APIs, production-grade resilience (where applicable), and full API parity.

Same API, Every Language

All SDKs implement identical domain coverage: 11 services (SKU, Product, Branch, Customer, Order, Offer, Brand, Category, Generic, Health, Integration) and canonical route parity across service operations.

Feature	C# Modern	C# Legacy	TypeScript	Python	Dart	Kotlin	Rust	Swift	Go	C++	Zig
Async I/O	`async/await`	`async/await`	`Promise`	`asyncio`	`Future`	`suspend`	`async/await`	`async/await`	`context.Context`	`std::future`	explicit async
Serialization	System.Text.Json	Newtonsoft.Json	Native JSON	dataclasses	Hand-written	kotlinx.serialization	serde	Codable	encoding/json	user-defined	user-defined
HTTP Client	`HttpClient`	`HttpClient`	`fetch`	`httpx`	`dio`	OkHttp	reqwest	URLSession	net/http	pluggable	pluggable
Streaming	`IAsyncEnumerable`	Batch Tasks	`AsyncIterator`	`async for`	`Stream`	`Flow`	`Stream`	`AsyncSequence`	channels	iterators	iterators
Resilience	✅ Built-in	✅ Built-in	✅ Built-in	✅ Built-in	✅ Built-in	✅ Built-in	✅ Built-in	✅ Built-in	✅ Built-in	transport	transport
Builders	✅ Fluent	✅ Fluent	✅ Fluent	✅ Fluent	✅ Fluent	✅ Fluent	✅ Fluent	✅ Fluent	✅ Options	service methods	✅ Fluent
Validation	✅ On build	✅ On build	✅ On build	✅ On build	✅ On build	✅ On build	✅ On build	✅ On build	✅ On call	✅ Constructor	✅ On build
Package	NuGet	NuGet	npm	pip	pub	Maven	Cargo	SPM	go get	CMake	Zig build
External Deps	Zero	Newtonsoft.Json	Zero	httpx	dio	OkHttp	reqwest, serde	Zero	Zero	Zero	Zero

Common Patterns

Every SDK follows these patterns:

Client Initialization

await using var client = await LinkitClient.CreateClientAsync(
    config => config.WithBaseUrl("https://linkit.works/api/v1"),
    jwtToken: "your-jwt-token"
);

using var client = await LinkitClient.CreateClientAsync(
    config => config.WithBaseUrl("https://linkit.works/api/v1"),
    jwtToken: "your-jwt-token"
);

const client = LinkitClient.quickSetup("https://linkit.works/api/v1", "your-jwt-token");

client = LinkitClient.quick_setup("https://linkit.works/api/v1", "your-jwt-token")

final client = LinkitClient.quickSetup('https://linkit.works/api/v1', 'your-jwt-token');

val client = LinkitClient.quickSetup("https://linkit.works/api/v1", "your-jwt-token")

let client = LinkitClient::builder()
    .base_url("https://linkit.works/api/v1")
    .build()?
    .with_auth("your-jwt-token").await?;

let client = try LinkitClient.quickSetup(
    baseUrl: "https://linkit.works",
    jwtToken: "your-jwt-token"
)

client, err := linkit.QuickSetup("https://linkit.works/api/v1", "your-jwt-token")

auto transport = std::make_shared<MyHttpTransport>();
auto client = linkit::Client::quick_setup(
    "https://linkit.works/api/v1",
    "your-jwt-token",
    transport
);

var client = try linkit.Client.init(allocator, .{
    .base_url = "https://linkit.works/api/v1",
    .jwt_token = "your-jwt-token",
}, .{
    .ctx = &transport_state,
    .send_fn = my_send_fn,
});

Fluent Builders

await client.Skus()
    .UpdateStock("SKU-001", "BR-RYD")
    .SetQuantity(500)
    .SetAvailability(true)
    .ExecuteAsync();

await client.Skus()
    .UpdateStock("SKU-001", "BR-RYD")
    .SetQuantity(500)
    .SetAvailability(true)
    .ExecuteAsync()
    .ConfigureAwait(false);

const sku = new SkuCreateBuilder()
    .withIvId("SKU-001")
    .inBranch("BR-RYD")
    .forProduct("P-001")
    .withPrice(29.99)
    .build();

sku = (SkuCreateBuilder()
    .with_iv_id("SKU-001")
    .in_branch("BR-RYD")
    .for_product("P-001")
    .with_price(29.99)
    .build())

final sku = (SkuCreateBuilder()
    ..withIvId('SKU-001')
    ..inBranch('BR-RYD')
    ..forProduct('P-001')
    ..withPrice(29.99))
    .build();

val sku = SkuCreateBuilder()
    .withIvId("SKU-001")
    .inBranch("BR-RYD")
    .forProduct("P-001")
    .withPrice(29.99)
    .build()

let sku = client.skus().create()
    .iv_id("SKU-001")
    .branch_iv_id("BR-RYD")
    .product_iv_id("P-001")
    .price(29.99)
    .send().await?;

let sku = try await client.skus.create(
    SKURequest(
        ivId: "SKU-001",
        branchIvId: "BR-RYD",
        productIvId: "P-001",
        price: 29.99,
        qty: 100,
        available: true
    )
)

sku, err := client.SKUs.Create(ctx, &linkit.SKURequest{
    IvID: "SKU-001", BranchIvID: "BR-RYD",
    ProductIvID: "P-001", Price: ptr(29.99),
})

auto sku = client.skus().create(linkit::SkuRequest{
    .iv_id = "SKU-001",
    .branch_iv_id = "BR-RYD",
    .product_iv_id = "P-001",
    .price = 29.99
});

var sku_builder = linkit.SkuCreateBuilder{};
const sku = try sku_builder
    .withIvId("SKU-001")
    .inBranch("BR-RYD")
    .forProduct("P-001")
    .withPrice(29.99)
    .build();

Resilience Pipeline

Every request flows through a 3-layer resilience pipeline — automatically:

Rate Limiter — Controls concurrent requests (default: 10)
Circuit Breaker — Opens after N failures, auto-recovers via half-open state
Retry with Jitter — Exponential backoff + random jitter for transient errors (5xx, 429, timeouts)

C++ and Zig SDKs use a transport-first design — resilience is delegated to whichever HTTP transport you inject. All other SDKs implement the resilience pipeline internally.

No configuration needed — sensible defaults are applied. Override via LinkitConfiguration.

SDK Reference

SDK Reference

Choose Your SDK

C# / .NET 10 (Modern)

C# / .NET Framework 4.8 (Legacy)

TypeScript

Python

Dart / Flutter

Kotlin / JVM

Rust

Swift

Go

C++20

Zig

Architecture Comparison

Common Patterns

Client Initialization

Fluent Builders

Resilience Pipeline

On this page