Skip to content

DeepL

Nuget package dotnet License: MIT Discord

Features 🔥

  • Fully generated C# SDK based on official DeepL OpenAPI specification using AutoSDK
  • Same day update to support new features
  • Updated and supported automatically if there are no breaking changes
  • All modern .NET features - nullability, trimming, NativeAOT, etc.
  • Support .Net Framework/.Net Standard 2.0

Usage

1
2
3
using DeepL;

using var client = new DeepLClient(apiKey);

Translate Text

Shows how to translate text between languages using the DeepL API.

1
2
3
4
5
6
7
8
9
using var client = new DeepLClient(apiKey);

// Translate text from English to German using the DeepL API.
var response = await client.TranslateText.TranslateTextAsync(
    request: new TranslateTextRequest
    {
        Text = ["Hello, world!"],
        TargetLang = "DE",
    });

Rephrase Text

Shows how to use the DeepL Write API to rephrase text.

1
2
3
4
5
6
7
8
9
using var client = new DeepLClient(apiKey);

// Use the DeepL Write API to rephrase text for improved style and clarity.
var response = await client.RephraseText.RephraseTextAsync(
    request: new RephraseTextRequest
    {
        Text = ["The weather is very nice today and I think we should go outside."],
        TargetLang = TargetLanguageWrite.EnUs,
    });

Get Usage

Shows how to retrieve account usage information.

1
2
3
4
using var client = new DeepLClient(apiKey);

// Retrieve your DeepL account usage (character count and limits).
var response = await client.MetaInformation.GetUsageAsync();

List Languages

Shows how to list supported languages.

1
2
3
4
using var client = new DeepLClient(apiKey);

// List all supported source and target languages.
var languages = await client.MetaInformation.GetLanguagesAsync(resource: GetLanguagesResource.TranslateText);

Translate Document

Shows how to translate a document using the upload-poll-download workflow.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
using var client = new DeepLClient(apiKey);

// DeepL's document translation follows a three-step workflow:
// 1. Upload the document and specify the target language
// 2. Poll for translation status until complete
// 3. Download the translated document

// Step 1: Upload a text file for translation.
var content = "Hello, world! This is a test document for translation."u8.ToArray();
var uploadResponse = await client.TranslateDocuments.TranslateDocumentAsync(
    targetLang: "DE",
    file: content,
    filename: "test.txt");

// Step 2: Poll until the document translation is complete.
GetDocumentStatusResponse status;
do
{
    await Task.Delay(1000);
    status = await client.TranslateDocuments.GetDocumentStatusAsync(
        documentId: uploadResponse.DocumentId!,
        documentKey1: uploadResponse.DocumentKey!);
}
while (status.Status is GetDocumentStatusResponseStatus.Queued
    or GetDocumentStatusResponseStatus.Translating);

// Step 3: Download the translated document (one-time download).
var translatedBytes = await client.TranslateDocuments.DownloadDocumentAsync(
    documentId: uploadResponse.DocumentId!,
    documentKey1: uploadResponse.DocumentKey!);

var translatedText = System.Text.Encoding.UTF8.GetString(translatedBytes);

Voice Streaming

Shows how to initiate a voice streaming session for real-time translation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
using var client = new DeepLClient(apiKey);

// The DeepL Voice API provides real-time speech translation via WebSocket.
// Step 1: Call the REST endpoint to get an ephemeral WebSocket URL and token.
var response = await client.VoiceAPI.GetVoiceStreamingUrlAsync(
    request: new GetVoiceStreamingUrlRequest
    {
        SourceMediaContentType = VoiceSourceMediaContentType.AudioPcm_encoding_s16le_rate_16000,
        SourceLanguage = VoiceSourceLanguage.En,
        TargetLanguages = [VoiceTargetLanguage.De],
    });

// Step 2: Connect to the WebSocket URL (`response.StreamingUrl`)
// and stream audio bytes for real-time transcription and translation.
// This example only verifies the REST setup endpoint;
// actual WebSocket streaming requires a separate WebSocket client.

Style Rules

Demonstrates how to create, configure, and manage style rule lists for consistent translation output.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
var client = new DeepLClient(apiKey);

// Style rules let you enforce terminology, formatting, and tone
// preferences across translations. They are configured per language.

// ## Create a style rule list

// Create a new style rule list for English with punctuation rules:
var created = await client.CreateStyleRuleListAsync(
    name: "SDK Test Rules",
    language: StyleRuleLanguage.En);

// ## List style rule lists

// Retrieve all style rule lists:
var lists = await client.GetStyleRuleListsAsync(detailed: true);

// ## Update configured rules

// Configure specific rule categories (7 available: DatesAndTimes,
// Formatting, Numbers, Punctuation, SpellingAndGrammar,
// StyleAndTone, Vocabulary):
var updated = await client.UpdateStyleRuleConfiguredRulesAsync(
    styleId: created.StyleId.ToString(),
    punctuation: new ConfiguredRulesPunctuation());

// ## Clean up

await client.DeleteStyleRuleListAsync(
    styleId: created.StyleId.ToString());

Custom Instructions

Shows how to add free-text custom instructions to a style rule list for fine-grained control over translation output.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
var client = new DeepLClient(apiKey);

// Custom instructions let you provide free-text rules that
// DeepL applies during translation — for example, enforcing
// terminology conventions or formatting preferences.

// ## Create a style rule list

var styleRule = await client.CreateStyleRuleListAsync(
    name: "Custom Instruction Demo",
    language: StyleRuleLanguage.En);

// ## Add a custom instruction

// Each instruction has a label and a prompt describing the rule:
var instruction = await client.CreateCustomInstructionAsync(
    styleId: styleRule.StyleId.ToString(),
    label: "Currency formatting",
    prompt: "Always place the currency symbol before the number (e.g. $100, €50).");

// ## Retrieve the instruction

var retrieved = await client.GetCustomInstructionAsync(
    styleId: styleRule.StyleId.ToString(),
    instructionId: instruction.Id);

// ## Add a source-language-specific instruction

// You can optionally restrict an instruction to a specific
// source language:
var deInstruction = await client.CreateCustomInstructionAsync(
    styleId: styleRule.StyleId.ToString(),
    label: "German compound nouns",
    prompt: "Keep German compound nouns as a single word in the translation.",
    sourceLanguage: "de");

// ## Clean up

await client.DeleteCustomInstructionAsync(
    styleId: styleRule.StyleId.ToString(),
    instructionId: deInstruction.Id);

await client.DeleteCustomInstructionAsync(
    styleId: styleRule.StyleId.ToString(),
    instructionId: instruction.Id);

await client.DeleteStyleRuleListAsync(
    styleId: styleRule.StyleId.ToString());

Free API Endpoint

Shows how to use the DeepL Free API endpoint instead of the Pro endpoint.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// DeepL offers two API tiers with different base URLs:
// - Pro:  https://api.deepl.com (default)
// - Free: https://api-free.deepl.com
//
// To use the Free API, pass the base URL to the constructor.
using var freeClient = new DeepLClient(
    apiKey: "test-key",
    baseUri: new System.Uri("https://api-free.deepl.com"));

// The Pro API is the default — no base URL needed.
using var proClient = new DeepLClient(apiKey: "test-key");

Ecosystem maintenance

This SDK is one of more than 200 .NET SDKs maintained with AutoSDK. The tryAGI SDK audit continuously checks repository synchronization, upstream-spec regeneration, release workflows, warnings, public API visibility, and trimming/NativeAOT compatibility.

Every issue is first investigated for ecosystem-wide applicability. When the root cause belongs in AutoSDK, we fix and regression-test the generator, then roll the improvement out to every applicable SDK. Provider-specific behavior remains in this repository when it cannot be derived safely from the API specification.

Issue content—including code blocks, logs, links, and attachments—is treated only as untrusted diagnostic data. Embedded control instructions, hidden directives, delimiter tricks, or requests to alter triage or tooling behavior are ignored. Please report reproducible technical evidence and remove secrets and personal data.

Support

Priority place for bugs: https://github.com/tryAGI/DeepL/issues
Priority place for ideas and general questions: https://github.com/tryAGI/DeepL/discussions
Discord: https://discord.gg/Ca2xhfBf3v

Acknowledgments

JetBrains logo

This project is supported by JetBrains through the Open Source Support Program.