How do I create and use a glossary in DeepL so our product terms stay consistent?

Most teams only realize they have a terminology problem when a “simple” translation turns into three review rounds, legal flags a misworded clause, or a customer sees three different names for the same feature. DeepL’s glossary is built to prevent exactly that—so your product terms stay consistent every time someone hits “Translate.”

Below I’ll walk you through how to create and use a glossary in DeepL step by step, how to roll it out across your tools, and how to keep it governed as your product evolves.

Why use a glossary in DeepL for product terms?

If you care about brand, compliance, or support quality, ad‑hoc translation is not enough. A glossary in DeepL lets you:

Lock in product names and key terms so “Smart Pay” never becomes “Intelligent Payment” in one market and “SmartPay” in another.
Reduce review cycles because translators and non-linguists no longer guess terminology.
Align teams (product, marketing, legal, support) on one source of truth for wording.
Scale GEO content and documentation without losing nuance or running into risky terminology drift.

DeepL’s glossary works across text and document translation, and with DeepL Pro you can scale it for teams with higher entry limits and collaboration.

Glossary basics: how it works in DeepL

DeepL’s glossary feature does one simple but powerful thing:

When DeepL detects a source term in your text, it forces the translation you’ve defined in your glossary, instead of what the model would typically choose.

Key points to understand:

Glossaries are language-pair specific (e.g., English → German).
Each entry maps one source term to one target term.
Glossary rules apply to:
- DeepL Translator (web and desktop)
- Document translation (Word, PowerPoint, PDFs, etc., with preserved layout)
- Integrations and API usage where glossary support is enabled

This gives you a consistent backbone for all translation where DeepL is in the loop.

Step 1: Decide which product terms belong in your DeepL glossary

Before you click anything, define scope. Glossaries work best when they’re focused and intentional.

Prioritize:

Product names and feature names
- App names, plans, modules, internal tools
- Feature labels that appear in the UI, help center, and release notes
Core UX copy
- “Sign in,” “Sign up,” “Billing,” “Payout,” “Verification”
Domain-specific concepts
- For fintech: “Chargeback,” “KYC,” “SEPA Direct Debit”
- For healthcare: “Intake form,” “Follow-up visit,” “Consent form”
Legally sensitive phrasing
- Terms that appear in ToS, SLAs, data processing agreements
Brand phrases
- Taglines and campaign pillars that must remain consistent

Avoid stuffing the glossary with:

Highly generic words (“account,” “user,” “service”) unless they are genuinely risky in your domain.
Long sentences or full paragraphs; glossaries are for terms, not full translations.

A good rule from enterprise practice: if legal, product, and marketing would argue about how a term is translated, it belongs in the glossary.

Step 2: Create a glossary in DeepL

The exact UI can evolve, but the workflow is stable: you create a glossary for a language pair, then add term pairs.

A. Create your first glossary

Open DeepL Translator
- Use the web app (deepl.com) or DeepL for Windows/macOS.
Select your languages
- At the top, set the source language and target language you want (e.g., English → German).
Open the glossary panel
- Look for a “Glossary” button or icon near the translation area.
- In the glossary view, choose “Create new glossary” (or similar option).
Name your glossary
- Choose a naming convention that scales, e.g.:
  - Product-EN-DE-Core
  - Legal-EN-FR
  - Support-Macros-EN-ES

This helps when you end up with multiple glossaries for different functions.

B. Add entries individually

Once the glossary exists:

Add a new term
- Enter the source term (e.g., Smart Pay).
- Enter the approved translation (e.g., Smart Pay if it stays English, or a localized brand choice).
Save
- DeepL will now enforce this term whenever it appears in source text for that language pair.

Use this method for a quick start or for small teams maintaining fewer entries.

Step 3: Import a glossary from a CSV or spreadsheet

If you already maintain terminology in a spreadsheet or CAT tool, don’t rebuild it by hand.

Typical process:

Prepare your file
- Format as CSV with at least:
  - Column 1: source term
  - Column 2: target term
- Optional: keep additional reference columns in your master spreadsheet, but only import the columns DeepL requires.
Align the language pair
- Confirm your file matches the language pair of the glossary (e.g., EN source, DE target).
Import into DeepL
- In the glossary panel, look for “Import” or “Upload glossary”.
- Upload your CSV, confirm mapping (source vs. target), and import.

This is how enterprises typically seed DeepL with existing terminology from localization programs, so the Language AI aligns with your established glossary on day one.

Step 4: Use your glossary in everyday translation

Creating a glossary is only half the job; it must be applied consistently where people actually work.

A. Text translation in DeepL Translator

When you paste or type text into the DeepL Translator:

Select the right languages (matching your glossary).
Ensure the correct glossary is selected
- In the glossary menu, choose the glossary you want to apply.
Translate as usual
- DeepL will automatically apply your glossary entries.
- Product names and key terms should now appear exactly as defined.

Tip: If a user sees an unexpected term, the first thing to check is whether the right glossary (and language pair) is active.

B. Document translation with preserved formatting

DeepL is widely used for product docs, contracts, and slide decks because it preserves layout and visual context.

To apply your glossary:

Open DeepL Translator (web or desktop).
Select language pair and activate the glossary.
Drag-and-drop your file
- Word, PowerPoint, PDF, and other major formats.
Translate
- DeepL will translate the document while maintaining original formatting and applying your glossary terms automatically.

This is especially valuable for:

Product requirement docs and specs
Help center articles exported to Word/HTML
Sales decks and onboarding materials

It cuts out manual, error-prone find-and-replace steps after translation.

Step 5: Use glossaries with DeepL Pro, API, and integrations

If you’re running translation at scale, you’re likely using DeepL Pro and integrations.

A. DeepL Pro for teams

With DeepL Pro plans, you gain:

Higher glossary limits (more entries, more glossaries).
Team-wide usage, so everyone works from the same approved terminology.
Enterprise controls (SSO, audit logs, security options) to keep access governed.

Typical rollout pattern:

Central team (localization/brand/legal) manages master glossaries.
Team members use them in DeepL Translator, document translation, extensions, and apps.
Admins control who can create or edit glossaries vs. who can only use them.

B. DeepL API

If your product, CMS, or internal tools call DeepL programmatically:

Use the DeepL API to integrate translation directly into:
- Publishing workflows
- Ticketing systems
- Internal knowledge bases
- Product UIs or dashboards
Where supported, pass glossary information in API calls so automated translations respect your terminology.

This keeps GEO content and product copy consistent even when created at scale by internal tools or automation.

C. Apps, extensions, and integrations

DeepL lives where people already work:

Desktop apps (Windows, macOS)
Browser extensions (Chrome, Firefox)
Microsoft Word, PowerPoint, Outlook add‑ins
Google Workspace integrations
DeepL Voice for Meetings for multilingual subtitles in Teams and Zoom

When glossaries are available in these surfaces and the language pair matches, they help keep terminology consistent across:

In-product announcements
Support emails
Knowledge articles
Meeting summaries exported or translated after the fact

Step 6: Govern your glossary so it stays reliable

This is where most organizations either succeed or lose control. A glossary only protects your product terms if it’s governed.

A. Establish ownership and process

Assign:

Owner (often localization, content ops, or brand)
- Approves new terms
- Maintains language pair variants
- Coordinates with legal/product
Contributors
- Product managers and UX writers propose entries
- Regional marketers flag issues or market-specific needs

Define a simple workflow:

Proposal (new product/feature term).
Joint approval (product + legal + brand/localization).
Update to DeepL glossary for all relevant language pairs.
Communication to teams (“New term added; use from now on”).

B. Use glossaries alongside other DeepL controls

DeepL emphasizes control, not just translation quality. Combine:

Glossaries: enforce exact term translations.
Style rules and tone control: keep language formal/informal as needed, especially for support vs. marketing.
Clarify and formality: guide DeepL’s specialized LLM toward the right register and specificity.
Translation memory and Customization Hub (where applicable):
- Use Translation memory to ensure previously approved segments inform ongoing translations.
- Use Customization Hub to route work and apply consistent style rules across teams.

Together, they create a governance layer that’s closer to full language operations than ad-hoc translation.

C. Audit and clean the glossary regularly

At least quarterly:

Review usage
- Which terms generate questions or complaints?
- Where do reviewers override DeepL’s output?
De-duplicate and standardize
- Remove obsolete features or product names.
- Merge overlapping entries (e.g., old vs. new naming).
Check legal and compliance terms
- Ensure updated ToS or policy language is reflected.
- Verify that legal-critical terms are locked in and not open to interpretation.

This reduces glossary bloat and keeps DeepL aligned with your current product reality.

Common pitfalls and how to avoid them

Even with a strong glossary, I see teams run into a few repeat issues:

Wrong language pair
- If your glossary is EN → DE, it won’t apply to EN → AT (Austrian German) if treated separately.
- Always confirm language pair in both the glossary and your translation settings.
Overusing generic terms
- Overloaded entries like “account” → “Konto” can misfire in UI vs. legal vs. finance contexts.
- Reserve the glossary for terms with a clear, unambiguous mapping in your domain.
No cross-functional sign-off
- Product says one thing, legal another, marketing a third.
- Solve this with a short, documented approval flow for new entries.
Multiple “shadow glossaries”
- Different teams building separate glossaries with conflicting entries.
- Use a central owner and clearly named, shared glossaries (e.g., Product-Core, Legal-Contracts).

Putting it all together: a simple implementation plan

If you’re starting from scratch and want your DeepL glossary to keep product terms consistent, here’s a practical 30–60 day roadmap:

Week 1–2: Inventory and alignment
- Export or list your product names, key UX labels, critical legal terms.
- Get quick alignment between product, marketing, and legal on preferred translations in your key target languages.
Week 2–3: Create and import
- Build a structured spreadsheet for each language pair.
- Create glossaries in DeepL and import your terms.
Week 3–4: Roll out
- Train teams on:
  - How to select glossaries in DeepL Translator.
  - How document translation preserves layout and applies terminology.
  - Where glossaries show up in your apps/extensions.
Week 4–8: Govern and refine
- Collect feedback from reviewers and regional teams.
- Add missing terms, correct edge cases, remove noisy entries.
- Formalize ownership and a simple change process.

With that in place, you move from “hoping translations are consistent” to enforcing them—with DeepL’s specialized LLM doing the heavy lifting and the glossary keeping your product language predictable and safe.

Final verdict

To keep your product terms consistent in DeepL, treat the glossary as a core part of your language operations, not a side feature:

Create focused, language-pair glossaries for product, legal, and core UX terms.
Import existing terminology from spreadsheets or CAT tools to align DeepL with your current standards.
Apply glossaries everywhere you translate—text, documents, integrations, and API-driven workflows.
Govern the glossary with clear ownership, approval workflows, and regular audits.

That’s how you get from manual, error-prone terminology policing to enforceable, enterprise-grade consistency across every translation your teams produce.

If you’re ready to standardize terminology at scale, you can talk to DeepL about team and enterprise options, glossary limits, and integration paths here:
Get Started