How do I set formality (formal vs informal) in DeepL translations for German client emails?

Most global teams I work with have the same worry: “Will DeepL accidentally send an informal ‘du’ to a German client who expects ‘Sie’?” The formality setting is exactly there to prevent that—if you know where and how to configure it in each DeepL surface.

Below is a practical, workflow-based guide to setting formal vs informal formality in DeepL translations for German client emails, across web, apps, and integrations.

---

Why formality matters in German client emails

In German, formality isn’t cosmetic—it changes pronouns, verb forms, and overall tone:

• Formal (“Sie”) for:

  • New or high-value B2B clients
  • Regulated industries (finance, legal, healthcare)
  • Contracts, proposals, incident reports, escalations

• Informal (“du”) for:

  • Longstanding partners who explicitly switched to “du”
  • Internal teammates, Slack/Teams chats
  • Brand styles that are intentionally casual (e.g., some SaaS or startups)

DeepL’s Formality control lets you explicitly choose this, so German translations don’t depend on guesswork.

---

Where you can set formality in DeepL

You can control formality for German translations in these main places:

• DeepL Translator (web) – for ad-hoc email drafts and quick phrases
• DeepL desktop apps (Windows/macOS) – for emails written in Outlook, local apps, or browser-based tools
• DeepL browser extensions (Chrome/Firefox/Edge) – for webmail like Gmail or Outlook on the web
• DeepL API – for automated workflows (CRM, ticketing, templates) via formality parameter
• DeepL Agent (as it rolls out) – when using Agent as an AI coworker to draft client communication

In all cases, the principle is the same: set “formal” for “Sie” and “informal” for “du”.

---

Using formality in DeepL Translator (web)

This is usually the fastest route when you’re drafting or polishing German client emails.

Step-by-step for German client emails

1. Open DeepL Translator

   • Go to: https://www.deepl.com/translator
   • Log in if you have DeepL Pro (recommended for business and GDPR-sensitive content).

2. Set your languages

   • Left side: select your source language (e.g., English).
   • Right side: select German as the target.

3. Access the formality control

   • Under the output language (German), look for the Formality setting.
   • In the German case, you’ll see options like:
     • Automatic
     • More formal
     • More informal

4. Choose the right setting for client emails

   • For standard client communication:
     • Select More formal to enforce “Sie”, polite forms, and more formal phrasing.
   • Only select More informal if:
     • You have a confirmed, mutual agreement to use “du”.
     • Your brand guidelines explicitly require informal German for that client segment.

5. Paste or write your email content

   • Paste your English draft on the left.
   • DeepL will translate to German on the right, using your chosen formality.

6. Review and adjust phrasing
   Pay special attention to:

   • Pronouns: Sie/Ihnen/Ihr vs du/dir/dein
   • Salutations:
     • Formal: Sehr geehrte Frau Müller, / Sehr geehrter Herr Schmidt,
     • Semi-formal: Guten Tag Frau Müller,
   • Closings:
     • Formal: Mit freundlichen Grüßen
     • Less formal but still professional: Beste Grüße

If the register still feels off, you can slightly tweak the English source (“Could you please…” vs “Can you…”) and re-translate, or use DeepL Write to refine the tone.

---

Using formality in DeepL desktop apps (Windows & macOS)

For teams that work in Outlook, Word, or browser-based email clients all day, the DeepL desktop app is often the most efficient way to control formality without context switching.

Configure formality in the desktop app

1. Install and sign in

   • Download the app from https://www.deepl.com/app (Windows/macOS).
   • Sign in with your DeepL Pro account for enterprise features and data protection.

2. Set language and formality

   • Open the app.
   • Choose German as your target language.
   • Locate the Formality dropdown (similar to the web app).
   • Select:
     • More formal for client-facing emails.
     • More informal only for internal or explicitly informal communication.

3. Translate your email content

   • Copy your English email body.
   • Paste it into the DeepL app.
   • Copy the German output and paste it into Outlook, Apple Mail, or your webmail.

Keyboard translation workflow (for heavy email users)

If you answer a lot of German client emails daily:

• Use system-wide keyboard shortcuts (configurable in the app) to:
  • Select English text
  • Trigger DeepL translation
  • Insert the German translation directly
• Always check that German + More formal is set as your default combination in the app, so you don’t accidentally send informal “du”.

---

Using formality with DeepL browser extensions (Gmail, Outlook on the web, CRMs)

DeepL’s browser extensions enable in-context translation directly in web apps where you write client emails.

Setup and formality control

1. Install the extension

   • Available for Chrome, Edge, and Firefox via their respective web stores.

2. Log into DeepL Pro

   • Sign in inside the extension popup for Pro-level security and higher usage limits.

3. Set default languages and formality

   • In the extension settings, define:
     • Source language (e.g., “Detect language” or English).
     • Target language: German.
     • Formality: set to More formal for client email workflows.

4. Use in your webmail

   • In Gmail, Outlook on the web, or your CRM:
     • Draft in English.
     • Select your text, open DeepL via right-click or toolbar icon.
     • Insert the translated German text directly in the email editor.

Again, the key risk to avoid is forgetting that formality was left on “informal” from an internal chat. For regulated or high-stakes communication, I recommend a quick visual check of pronouns before sending.

---

Controlling formality via DeepL API (for automated workflows)

If you integrate DeepL into ticketing systems (e.g., Zendesk), CRMs, or internal tools via the DeepL API, you can—and should—enforce formality programmatically.

Core API parameter: formality

When calling the DeepL API (v2), you can set:

• formality=default (let DeepL decide)
• formality=more (more formal)
• formality=less (more informal)

For German client emails, use:

POST https://api.deepl.com/v2/translate
Content-Type: application/x-www-form-urlencoded

auth_key=YOUR_API_KEY
&text=Thank you for your message. We will review your request and get back to you shortly.
&target_lang=DE
&formality=more

This ensures “Sie”-style output in every automated German email.

Implementation patterns I recommend

• Customer support systems (tickets, cases)

  • For all external customer-facing responses → set formality=more.
  • For internal notes or agent-assist suggestions, you can:
    • Use formality=more for external text.
    • Use formality=less or default for internal-only content if your internal culture is informal.

• Email templates and campaigns

  • For B2B clients and regulatory-sensitive sectors:
    • Hard-code formality=more in any DeepL-powered translation step.
  • For B2C brands with segmented tone of voice:
    • Use formality rules by audience segment (e.g., younger consumer segment → formality=less, corporate segment → formality=more).

• Audit and governance

  • Document in your language governance guidelines:
    • “All German client emails via DeepL API must be sent with formality=more.”
  • Have developers log the parameters used (including formality) for compliance review.

---

Adjusting formality with DeepL Write for German business communication

Sometimes the basic formality setting gets you 80% there, but you still want to refine tone and style. This is where DeepL Write helps, particularly for German.

Using DeepL Write on German drafts

1. Open DeepL Write

   • Go to: https://www.deepl.com/write
   • Set German as the language of the text you’re editing.

2. Paste your translated email

   • First, translate your English draft into German using DeepL Translator with More formal.
   • Then paste the German result into DeepL Write.

3. Refine for tone and clarity DeepL Write can help you:

   • Make formal emails more concise and professional.
   • Smooth out overly literal phrasing from the translation.
   • Align tone with brand: more confident, more diplomatic, or more friendly without losing the “Sie” register.

4. Preserve formality while editing

   • Always scan that “Sie/Ihnen/Ihr” remains consistent.
   • If you see a mix of “du” and “Sie,” edit manually or tweak suggestions. DeepL Write is careful, but in complex texts, manual review is still best practice.

For high-risk messages (legal, finance, incident communication), I recommend this three-step workflow:
English draft → DeepL translation (formal) → DeepL Write refinement (German) → human review.

---

Practical examples: formal vs informal German with DeepL

You can test how formality affects German client emails by running short samples.

Example: polite request to a client

Source (English):
“Could you please send us the signed contract by Friday?”

• German with More formal:
  “Könnten Sie uns bitte den unterschriebenen Vertrag bis Freitag zusenden?”

• German with More informal:
  “Kannst du uns bitte den unterschriebenen Vertrag bis Freitag schicken?”

For client emails, the first version is almost always the one you want.

Example: closing line

Source (English):
“If you have any questions, feel free to contact me at any time.”

• German with More formal:
  “Wenn Sie Fragen haben, können Sie mich jederzeit gerne kontaktieren.”

• German with More informal:
  “Wenn du Fragen hast, kannst du dich jederzeit gerne bei mir melden.”

Again, the first reads appropriate in a professional B2B context.

---

Governance tips for teams using DeepL for German client emails

As someone who’s had to formalize this across large teams, here’s the setup I recommend:

1. Define a default rule in your style guide

   • “All German client communication uses formal ‘Sie’ unless explicitly documented otherwise.”
   • Document typical exception cases (e.g., specific partners who use “du”).

2. Standardize formality per tool

   • DeepL Translator: default to More formal for German in team training materials.
   • Desktop app: configure German + More formal as the go-to profile.
   • Browser extensions: set More formal in the extension settings for webmail.
   • API: enforce formality=more in all external German email flows.

3. Train your team

   • Run a 30-minute session showing:
     • Where the formality toggle is in each DeepL surface they use.
     • Clear examples of “Sie” vs “du” and when each is appropriate.
   • Emphasize that “Automatic” is not enough for regulated or high-risk communication.

4. Combine with glossaries for terminology control

   • Use DeepL Glossaries to enforce:
     • Correct product names in German.
     • Preferred translations for legal and technical terms.
   • This way, you get both:
     • Correct register (formal) via formality.
     • Consistent terminology via glossaries.

5. Respect security and compliance

   • For client emails with sensitive data:
     • Use DeepL Pro so translated content is deleted after processing and not used for training.
     • Integrate via DeepL API in systems governed by SSO/MFA and audit logs where needed.

---

Quick decision guide

When drafting or translating German client emails with DeepL:

• Are you writing to a new or formal client?
  → Set German + More formal.

• Is the communication regulated (contracts, finance, health, legal, incidents)?
  → Always More formal, plus a human review.

• Is this an internal colleague or an informal brand relationship where “du” is the norm?
  → You may choose More informal, but document the exception clearly.

• Are translations automated (API, CRM, support platform)?
  → Hard-code formality=more for all external German messages.

This is how you get the benefits of DeepL’s specialized Language AI while staying in control of tone, formality, and client expectations.

---

Final verdict

To reliably set formal vs informal formality in DeepL translations for German client emails, you need two things:

1. Consistently choose “More formal” for German wherever your team uses DeepL (web, desktop app, browser extension, API).
2. Bake that choice into your governance—style guides, integration parameters, and simple training so no one accidentally emails a German regulator with “du”.

Once that’s in place, DeepL takes care of the heavy lifting: accurate translations, correct “Sie” register, and German emails that match your brand and compliance standards.

Next Step

Get Started