Skip to main content

Translation

Automatically translate transcribed content to multiple languages.

Overview​

Translation capabilities help you:

  • Translate call transcripts to different languages
  • Support multilingual operations
  • Break language barriers
  • Create accessible records
  • Enable global communication analysis

Supported Languages​

The Translation API supports translation to all 100+ supported languages including:

  • European: English, Spanish, French, German, Italian, Portuguese, Dutch, Swedish, Danish, Norwegian, Polish, Czech, Romanian, Hungarian, Greek
  • Asian: Chinese (Simplified & Traditional), Japanese, Korean, Hindi, Thai, Vietnamese, Indonesian, Tagalog, Sinhala, Khmer
  • Middle Eastern: Arabic, Hebrew, Persian, Turkish, Urdu
  • Other: Russian, Hebrew, Turkish, and many more

How It Works​

Translation is applied to:

  1. Transcribed text: The conversation text
  2. Call summaries: The auto-generated summary
  3. Extracted entities: Names, locations, organizations
  4. Keywords: Important terms and phrases

Getting Translated Content​

Translate Transcript​

curl -X POST "https://api.example.com/api/v1/transcripts/123456789/translate" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targetLanguage": "SPANISH"
  }'

Response​

{
  "originalLanguage": "ENGLISH",
  "targetLanguage": "SPANISH",
  "originalTranscription": "Hello, how can I help you today?",
  "translatedTranscription": "Hola, ¿cómo puedo ayudarte hoy?",
  "translatedSummary": "El cliente llamó para inquierir sobre el estado del pedido..."
}

Translation Quality​

Translation quality depends on:

  1. Source Transcription Quality

    • Accurate transcription is essential
    • Errors compound in translation
    • Proper punctuation helps

  2. Language Pair

    • More common pairs: higher quality
    • Rare language pairs: variable quality
    • Domain-specific terms may need review

  3. Context

    • Provide industry context
    • Use domain-specific models when available
    • Review for accuracy

Integration Example​

Python​

import requests

class TranslationService:
    def __init__(self, api_base, token):
        self.api_base = api_base
        self.headers = {"Authorization": f"Bearer {token}"}
    
    def translate_transcript(self, transcript_id, target_language):
        """Translate transcript to target language"""
        response = requests.post(
            f"{self.api_base}/api/v1/transcripts/{transcript_id}/translate",
            headers=self.headers,
            json={"targetLanguage": target_language}
        )
        return response.json()
    
    def translate_to_multiple_languages(self, transcript_id, languages):
        """Translate to multiple languages"""
        translations = {}
        for lang in languages:
            translation = self.translate_transcript(transcript_id, lang)
            translations[lang] = translation
        return translations
    
    def get_translated_content(self, transcript_id, target_language):
        """Get translated content organized by type"""
        translation = self.translate_transcript(transcript_id, target_language)
        
        return {
            'language': target_language,
            'transcript': translation.get('translatedTranscription'),
            'summary': translation.get('translatedSummary'),
            'confidence': translation.get('confidence', 0.9)
        }

# Usage
translator = TranslationService("https://api.example.com", "your_token")

# Translate to Spanish
spanish = translator.translate_transcript(123456789, "SPANISH")
print("Spanish Translation:", spanish)

# Translate to multiple languages
languages = ["SPANISH", "FRENCH", "GERMAN", "CHINESE"]
translations = translator.translate_to_multiple_languages(123456789, languages)
for lang, translation in translations.items():
    print(f"{lang}: {translation['translatedTranscription'][:100]}...")

Use Cases​

1. Multilingual Support​

  • Support global customers
  • Document conversations in multiple languages
  • Enable team collaboration across regions
  • Maintain record in preferred language

2. Compliance & Audit​

  • Create records in required languages
  • Meet regulatory language requirements
  • Generate multilingual transcripts
  • Support audits in multiple languages

3. Training & Development​

  • Share call examples across language regions
  • Create multilingual training materials
  • Improve training content accessibility
  • Enable global best practice sharing

4. Customer Service​

  • Provide transcripts in customer's language
  • Support multilingual quality assurance
  • Train multilingual agents
  • Maintain language-specific standards

5. Business Intelligence​

  • Analyze calls across language regions
  • Identify global trends
  • Compare metrics across languages
  • Generate multilingual reports

Translation Confidence​

Each translation includes a confidence score:

{
  "translatedText": "...",
  "confidence": 0.94,
  "confidenceLevel": "High"
}

Confidence Levels:

  • 0.9+: Very High - Use as-is
  • 0.75-0.89: High - Suitable with review
  • 0.5-0.74: Medium - Review recommended
  • <0.5: Low - Manual review required

Professional Human Review​

For important documents:

  1. Legal Compliance

    • Use certified translators for legal matters
    • Maintain verified translations
    • Get translation certification if required

  2. Quality Assurance

    • Always have humans review
    • Verify terminology accuracy
    • Check cultural appropriateness

  3. Document Control

    • Version translations
    • Track revisions
    • Maintain audit trail

Domain-Specific Translation​

Medical/Healthcare​

def translate_medical_transcript(transcript_id, api_token):
    """Translate medical transcript with medical terminology"""
    translator = TranslationService("https://api.example.com", api_token)
    
    # Use medical domain model if available
    translation = translator.translate_transcript(
        transcript_id,
        target_language="SPANISH",
        domain="MEDICAL"
    )
    
    return translation
def translate_legal_document(transcript_id, api_token):
    """Translate legal document with legal terminology"""
    translator = TranslationService("https://api.example.com", api_token)
    
    # Use legal domain model
    translation = translator.translate_transcript(
        transcript_id,
        target_language="SPANISH",
        domain="LEGAL"
    )
    
    # Mark for human review
    return {
        'translation': translation,
        'requires_human_review': True,
        'suggested_reviewer': 'Legal Team'
    }

Workflow Integration​

Multilingual QA Process​

def multilingual_qa_workflow(transcript_id, api_token):
    """Quality assurance in multiple languages"""
    
    translator = TranslationService("https://api.example.com", api_token)
    
    # Get original and translations
    languages = ["ENGLISH", "SPANISH", "FRENCH", "GERMAN"]
    results = {}
    
    for lang in languages:
        if lang == "ENGLISH":
            # Get original
            response = requests.get(
                f"https://api.example.com/api/v1/transcripts/{transcript_id}/status",
                headers={"Authorization": f"Bearer {api_token}"}
            )
            results[lang] = response.json()
        else:
            # Get translation
            results[lang] = translator.translate_transcript(transcript_id, lang)
    
    # QA check
    qa_results = {
        'transcript_id': transcript_id,
        'translations': results,
        'qa_status': 'complete'
    }
    
    return qa_results

Performance Considerations​

Translation Time​

  • Single language: 5-30 seconds
  • Multiple languages: Processed sequentially
  • Large transcripts: May take longer
  • Cache translations when possible

Cost Implications​

  • Each translation incurs a charge
  • Batch translations more efficient
  • Multi-language processing available
  • Enterprise plans may include unlimited

Best Practices​

1. Quality Assurance​

  • Always review AI translations
  • Verify terminology accuracy
  • Check cultural appropriateness
  • Use human translators for critical content

2. Domain Expertise​

  • Use domain-specific models when available
  • Provide context for specialized terms
  • Maintain terminology glossaries
  • Train translators on domain knowledge

3. Workflow Integration​

  • Automate where appropriate
  • Flag for manual review
  • Track translation accuracy
  • Measure satisfaction

4. Compliance​

  • Ensure translation meets requirements
  • Maintain audit trails
  • Get necessary certifications
  • Document translation process

Troubleshooting​

Low Confidence Score​

  • Transcription may be unclear
  • Language pair may be less common
  • Specialized terminology present
  • Request human review

Inaccurate Translation​

  • Domain-specific terms may be mistranslated
  • Context dependent meanings
  • Idiomatic expressions
  • Request specialized translator

Missing Translation​

  • Language may not be fully supported
  • Requires custom model
  • Contact support for options

Next Steps​