Best Translation API
for C# and .NET

Most .NET projects do not need a vendor SDK to call a translation API. They need one HTTP call, a couple of records, and System.Text.Json. Here is what each option actually looks like in a modern C# project.

Google Translate (Google.Cloud.Translation.V2):

// dotnet add package Google.Cloud.Translation.V2
using Google.Cloud.Translation.V2;

// Requires a downloaded service account JSON file on disk
Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", "service-account.json");

TranslationClient client = await TranslationClient.CreateAsync();
TranslationResult result = await client.TranslateTextAsync("Hello world", "nl");

Console.WriteLine(result.TranslatedText);

DeepL (DeepL.net):

// dotnet add package DeepL.net
using DeepL;

var translator = new Translator(Environment.GetEnvironmentVariable("DEEPL_AUTH_KEY")!);
var result = await translator.TranslateTextAsync("Hello world", null, LanguageCode.Dutch);

Console.WriteLine(result.Text);

Langbly (HttpClient, no package):

using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json.Serialization;

public sealed record TranslateRequest(
    [property: JsonPropertyName("q")] string Q,
    [property: JsonPropertyName("target")] string Target,
    [property: JsonPropertyName("source")] string? Source = null,
    [property: JsonPropertyName("format")] string Format = "text");

public sealed record Translation(
    [property: JsonPropertyName("translatedText")] string TranslatedText,
    [property: JsonPropertyName("detectedSourceLanguage")] string? DetectedSourceLanguage);

public sealed record TranslateData(
    [property: JsonPropertyName("translations")] IReadOnlyList<Translation> Translations);

public sealed record TranslateResponse(
    [property: JsonPropertyName("data")] TranslateData Data);

using var http = new HttpClient { BaseAddress = new Uri("https://api.langbly.com/") };
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("LANGBLY_API_KEY"));

using var response = await http.PostAsJsonAsync(
    "language/translate/v2",
    new TranslateRequest("Hello world", Target: "nl"));

response.EnsureSuccessStatusCode();

var payload = await response.Content.ReadFromJsonAsync<TranslateResponse>();
Console.WriteLine(payload!.Data.Translations[0].TranslatedText);   // Hallo wereld
Console.WriteLine(payload.Data.Translations[0].DetectedSourceLanguage); // en

The request body is small on purpose: q and target are required, source and format are optional, and format accepts "text" or "html". Send "html" when you are translating Razor fragments or CMS content and you want tags left intact.

Note the response envelope. It is the Google Translate v2 shape, byte for byte, because Langbly is a drop-in replacement for that API. If you already have TranslationResponse DTOs from a Google integration, they deserialize against Langbly without a single edit. Swapping providers is a base address and a header.

There is no official Langbly NuGet package. Official SDKs cover Python, JavaScript/TypeScript, and PHP. In .NET that turns out to be a non-issue: HttpClient plus two records is less code than wiring up a vendor SDK, and you keep full control over serialization, timeouts, logging, and retries.

For anything beyond a console script, register a typed client. You get connection pooling, a single place for the base address and auth header, and a seam you can mock in tests.

The client:

public interface ITranslator
{
    Task<string> TranslateAsync(string text, string target, CancellationToken ct = default);
}

public sealed class LangblyTranslator(HttpClient http, ILogger<LangblyTranslator> logger) : ITranslator
{
    public async Task<string> TranslateAsync(string text, string target, CancellationToken ct = default)
    {
        using var response = await http.PostAsJsonAsync(
            "language/translate/v2",
            new TranslateRequest(text, target),
            ct);

        if (response.StatusCode is System.Net.HttpStatusCode.TooManyRequests)
        {
            var retryAfter = response.Headers.RetryAfter?.Delta;
            logger.LogWarning("Rate limited, retry after {RetryAfter}", retryAfter);
        }

        response.EnsureSuccessStatusCode();

        var payload = await response.Content.ReadFromJsonAsync<TranslateResponse>(ct);

        return payload?.Data.Translations.FirstOrDefault()?.TranslatedText
            ?? throw new InvalidOperationException("Translation response contained no translations.");
    }
}

Registration in Program.cs:

// dotnet user-secrets set "Langbly:ApiKey" "your-api-key"
// dotnet add package Microsoft.Extensions.Http.Resilience

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpClient<ITranslator, LangblyTranslator>((sp, http) =>
{
    var config = sp.GetRequiredService<IConfiguration>();

    http.BaseAddress = new Uri("https://api.langbly.com/");
    http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
        "Bearer",
        config["Langbly:ApiKey"] ?? throw new InvalidOperationException("Langbly:ApiKey is not configured."));
    http.Timeout = TimeSpan.FromSeconds(30);
})
.AddStandardResilienceHandler();   // Polly-backed retries, timeouts, circuit breaker

var app = builder.Build();

app.MapPost("/translate", async (TranslateBody body, ITranslator translator, CancellationToken ct) =>
    Results.Ok(new { translated = await translator.TranslateAsync(body.Text, body.Target, ct) }));

app.Run();

record TranslateBody(string Text, string Target);

If you are on an older target framework without Microsoft.Extensions.Http.Resilience, a hand-rolled Polly policy does the same job:

.AddPolicyHandler(HttpPolicyExtensions
    .HandleTransientHttpError()
    .OrResult(r => (int)r.StatusCode == 429)
    .WaitAndRetryAsync(3, attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt))));

Two things worth doing while you are in here. Keep the key in user secrets locally and in your platform's secret store in production, never in appsettings.json. And turn on <Nullable>enable</Nullable> in the csproj so the compiler tells you where a missing translation can slip through as null.

Compare that to the Google SDK, which wants a service account JSON file mounted somewhere your app can read it, plus a GCP project with the Translation API enabled. It works, but it is a lot of ceremony for one POST request.

Localization in .NET still runs on .resx files, and translating them by hand is nobody's favourite afternoon. Since .resx is just XML, a small utility can generate every satellite file from your neutral resources.

using System.Xml.Linq;

// Reads Strings.resx and writes Strings.nl.resx, Strings.de.resx, and so on.
static async Task TranslateResxAsync(
    ITranslator translator,
    string sourcePath,
    string targetLanguage,
    CancellationToken ct = default)
{
    var doc = XDocument.Load(sourcePath);

    var entries = doc.Root!
        .Elements("data")
        .Where(d => d.Attribute("type") is null && d.Attribute("mimetype") is null) // skip images and blobs
        .ToList();

    foreach (var entry in entries)
    {
        var value = entry.Element("value");
        if (value is null || string.IsNullOrWhiteSpace(value.Value))
            continue;

        value.Value = await translator.TranslateAsync(value.Value, targetLanguage, ct);
    }

    var outputPath = Path.ChangeExtension(sourcePath, $"{targetLanguage}.resx");
    doc.Save(outputPath);

    Console.WriteLine($"{outputPath}: {entries.Count} strings translated");
}

// Usage
foreach (var lang in new[] { "nl", "de", "fr", "es", "ja" })
    await TranslateResxAsync(translator, "Resources/Strings.resx", lang);

Two details that save you a bug report. First, filter out entries with a type or mimetype attribute, because those are icons and serialized objects, not user-facing text. Second, if your strings use composite format placeholders like {0}, add a check that the placeholder count matches before you save. A one-line assertion in the loop is cheaper than a FormatException in production.

For bigger resource sets, batch the calls with Parallel.ForEachAsync and a sensible MaxDegreeOfParallelism, and cache results by source string so repeated labels like "Save" are only paid for once. At $5 per million characters a full resource set for five languages usually lands inside the 500K characters/month free tier anyway.

The same pattern works for JSON localization files, Blazor IStringLocalizer resources, and XLIFF exports. Swap XDocument for whatever parser matches your format and keep the rest.

• Best Translation API for Python
• Best Translation API for JavaScript & Node.js
• Google Translate API vs Langbly
• Quickstart: your first translation in under 5 minutes
• Migrating from the Google Translate v2 API
• Try Langbly. 500K characters/month included