DeepL vs LLMs for Translation

This analysis compares DeepL with modern Large Language Models (LLMs) like OpenAI's GPT-4o, Anthropic's Claude 3.5 Sonnet, and Google's Gemini 1.5 Pro for translation tasks. As someone who has managed translation workflows for years - from Google Translate through DeepL's rise to today's LLMs - I'll provide a technical assessment of how these technologies stack up across key metrics.

Translation Quality

DeepL's Neural Translation Foundation

DeepL revolutionized machine translation with neural translation that grasped context better and produced more natural phrasing than predecessors. When DeepL launched, it demonstrated remarkably improved fluency and accuracy compared to Google Translate, with translations requiring far fewer manual corrections. DeepL excelled particularly with European languages, delivering near-human-level fluency in many cases.

DeepL built its reputation on context-aware accuracy and natural phrasing. It supported fewer languages than Google Translate but delivered noticeably better results for the languages it did cover (primarily English, German, French, and other major European languages).

LLM Translation Performance

The latest generation of LLMs has challenged DeepL's dominance. Despite being general-purpose AI rather than specialized translation engines, models like GPT-4, Claude 3.5 Sonnet, and Gemini 1.5 Pro now match or exceed DeepL's output quality in blind tests.

Recent evaluations show GPT-4 achieving translation quality (measured by COMET score) on par with top systems like DeepL for English to Spanish. Another study focusing on literary translation found LLMs producing more succinct and contextually nuanced translations than DeepL, which tends toward safer, more literal interpretations to avoid misunderstandings.

While DeepL may still hold a slight edge in certain language pairs (like German), the quality gap has narrowed significantly. For most practical purposes, top LLMs now deliver comparable or superior accuracy.

Stylistic Control

DeepL's Limited Customization

DeepL primarily focuses on fidelity to the source text's meaning. Its customization options are limited:

• Formality settings for some languages (formal vs. informal pronouns)
• Glossary feature to enforce specific terminology
• Basic formatting preservation

While excellent for consistent, accurate translation, DeepL lacks the ability to dynamically adapt style beyond these basic parameters. It doesn't let you change writing style on the fly or apply different styles to different document sections.

LLM Stylistic Adaptability

LLMs offer unprecedented stylistic control through instructional prompting:

• Ability to specify tone (formal, casual, technical, conversational)
• Brand voice adaptation ("translate using our friendly, conversational brand voice")
• Genre-specific translation ("translate in a press-release style with short factual sentences")
• Audience-specific adaptation ("translate for a technical audience while preserving terminology")

For example, with Claude or GPT-4, you can request a translation that mimics marketing tone after showing a few examples, resulting in output that requires minimal rewriting. This contextual adaptability substantially reduces post-editing needs when specific tones or styles are required.

The flexibility comes with a small risk - if prompts are misunderstood, the LLM might take excessive creative liberty. However, with proper instruction, LLMs reliably maintain the source content's intent while adapting stylistic elements.

Speed Performance

DeepL's Translation Throughput

Speed remains DeepL's major competitive advantage. Its API delivers:

• Near-instant translation (fractions of a second for sentences)
• Seconds for entire documents
• Optimized infrastructure for high-volume translation
• Ability to handle many parallel requests

DeepL's architecture is specifically designed for translation efficiency at scale. This speed advantage is critical for real-time applications or bulk processing.

LLM Processing Limitations

LLMs demonstrate significantly slower performance:

• Higher latency per request (several seconds for a few hundred words)
• Stricter rate limits on parallel requests
• 12-18× slower processing than traditional MT engines in benchmarks
• Approximately 15-20× slower than DeepL when measuring seconds per segment

These speed differences materialize clearly in production environments. While DeepL returns translations almost immediately, LLMs noticeably "generate" responses, resulting in a much slower experience for bulk translation needs.

For startups or enterprises dealing with real-time or high-volume translation (user-generated content, documentation, etc.), this performance gap remains a decisive factor in DeepL's favor.

Cost Efficiency

DeepL's Pricing Structure

DeepL uses character-based pricing:

• 500,000 characters per month free
• Approximately $25 per million characters translated
• Small monthly fee for API access
• Per-character cost: $0.000025

For context, one million characters equals roughly 200,000 English words.

LLM Token-Based Economics

LLMs use token-based pricing that translates to considerably lower per-character costs:

• GPT-3.5 Turbo: ~$1.5-$3 per million characters (10-15× cheaper than DeepL)
• GPT-4: ~$18 per million characters
• Claude 3.5 Sonnet: ~$2-$3 per million characters (varies by token type)
• Gemini 1.5 Pro: Comparable to other modern LLM pricing

This creates dramatic cost differences at scale. For 10 million characters (approximately 5,000 pages):

• DeepL: ~$250
• GPT-3.5: ~$20-$30
• GPT-4: ~$180
• Claude 3.5 Sonnet: ~$22.50

The cost gap becomes even more pronounced at higher volumes. For enterprises with substantial translation needs, LLMs offer an order of magnitude cost advantage in many cases, while maintaining competitive quality.

Handling Formatted Content and HTML

DeepL's Format Preservation

DeepL excels at preserving formatting:

• Built-in "preserve formatting" option
• Reliable HTML tag handling
• Accurate preservation of document structure
• Low risk of malformed output

When processing HTML, DeepL reliably translates text within tags while maintaining the exact tag structure. This consistency is valuable for HTML snippets, formatted documents, and structured text where formatting integrity is critical.

However, DeepL's approach is somewhat inflexible. It translates uniformly with limited control over specific elements. You cannot easily:

• Apply different translation approaches to different HTML elements
• Selectively skip translating certain attributes
• Target specific patterns within text

LLM Format Handling

LLMs offer more flexible format handling through instructional prompting:

• Ability to preserve specific elements while translating others
• Selective translation (e.g., "don't translate code blocks or comments")
• Custom instructions for handling different document sections
• Pattern-based preservation ("don't translate text matching this pattern")

For example, you can instruct an LLM: "Translate the text, but don't alter any HTML tags or attributes, and keep the <a> tags as they are." You can request that it translate visible text but leave HTML comments untouched.

This flexibility is powerful for complex documents with mixed content types. However, LLMs require careful prompting and occasionally produce errors with complex formatting. While generally reliable with clear instructions, LLMs don't have the built-in format guarantees that specialized translation engines provide.

Practical Implementation Differences

DeepL Integration

DeepL offers:

• Simple, purpose-built API
• Consistent, predictable behavior
• Straightforward integration patterns
• Limited but reliable feature set
• Document upload/download capabilities
• Minimal prompt engineering required

LLM Implementation

LLMs require:

• More complex prompt engineering
• System role definitions and instructions
• Format validation and error handling
• Potentially multiple API calls for large documents
• Output validation for complex formatting
• Temperature and token limit management

While LLMs provide more flexibility, they also demand more engineering effort to implement reliably, especially for formatted content. Some organizations address this by using DeepL for bulk translation and LLMs for refinement or special cases.

Ideal Use Cases

When DeepL Makes More Sense

• High-volume, time-sensitive translations
• Real-time translation needs (chat, live content)
• Simple, predictable workflows
• When guaranteed format fidelity is critical
• Basic business content where speed trumps stylistic adaptation
• When integration simplicity is a priority

When LLMs Are Advantageous

• Marketing content requiring tone adaptation
• Branded communications needing stylistic consistency
• Content requiring selective translation of parts
• When complex instructions must accompany translation
• Lower-volume, higher-value content
• Budget-sensitive large-scale translation projects
• When combining translation with other tasks (summarization, analysis)

Outlook

DeepL recently integrated their own LLM technology, suggesting convergence between specialized translation systems and general-purpose AI. But honestly, I think DeepL will have a hard time catching up with OpenAI, Anthropic and Google. Meanwhile, LLMs continue improving in reliability and speed.

The future likely holds:

• Further narrowing of quality gaps
• Speed improvements in LLMs
• More specialized LLM fine-tuning for translation
• Hybrid approaches that combine strengths of both systems
• Advanced control mechanisms for translation style and formatting

Conclusion

DeepL and modern LLMs represent different approaches to machine translation, each with distinct advantages. DeepL remains unmatched for speed and reliability, especially for high-volume needs. LLMs offer comparable quality with superior stylistic control and cost efficiency, but at the expense of speed.

The ideal choice depends on specific requirements:

• Need for speed and volume → DeepL
• Need for stylistic control and cost efficiency → LLMs
• Complex formatting with minimal engineering → DeepL
• Custom handling of document elements → LLMs

Many organizations now implement hybrid approaches, using DeepL for speed-critical operations and LLMs for content where nuance and customization matter or using them for post-processing DeepL results.

As general AI continues advancing, the distinction between specialized translation tools and general-purpose AI will likely continue blurring, ultimately benefiting users with more capable, flexible, and affordable translation options.

What I'm building

Delegate tasks. Get software.

Give Vroni a GitHub issue, bug report, spec, or rough idea. It reads the repo, plans the change, writes code, runs checks, and works toward a review-ready pull request.

Take a look at vroni.com