Detect Language

curl -X POST https://api.case.dev/translate/v1/detect \
  -H "Authorization: Bearer sk_case_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "Bonjour, comment allez-vous?"
  }'

casedev translate:v1 detect --q "Bonjour, comment allez-vous?"

import Casedev from 'casedev';

const client = new Casedev({ apiKey: 'sk_case_YOUR_API_KEY' });

const result = await client.translate.v1.detect({
  q: 'Bonjour, comment allez-vous?'
});

const detection = result.data.detections[0][0];
console.log(detection.language);   // "fr"
console.log(detection.confidence); // 0.98

import casedev

client = casedev.Casedev(api_key='sk_case_YOUR_API_KEY')

result = client.translate.v1.detect(
    q='Bonjour, comment allez-vous?'
)

detection = result.data.detections[0][0]
print(detection.language)   # "fr"
print(detection.confidence) # 0.98

result, _ := client.Translate.V1.Detect(ctx, casedev.TranslateV1DetectParams{
	Q: casedev.F("Bonjour, comment allez-vous?"),
})
fmt.Println(result.Data.Detections[0][0].Language)

casedev translate:v1 detect --q "Bonjour, comment allez-vous?"

const result = await client.translate.v1.detect({
  q: [
    'Hello, how are you?',
    'Hola, como estas?',
    'Bonjour, comment ca va?',
    'Guten Tag, wie geht es Ihnen?'
  ]
});

result.data.detections.forEach((detection, i) => {
  console.log(`Text ${i + 1}: ${detection[0].language}`);
});
// Text 1: en
// Text 2: es
// Text 3: fr
// Text 4: de

result = client.translate.v1.detect(
    q=[
        'Hello, how are you?',
        'Hola, como estas?',
        'Bonjour, comment ca va?',
        'Guten Tag, wie geht es Ihnen?'
    ]
)

for i, detection in enumerate(result.data.detections):
    print(f'Text {i + 1}: {detection[0].language}')
# Text 1: en
# Text 2: es
# Text 3: fr
# Text 4: de

result, _ := client.Translate.V1.Detect(ctx, casedev.TranslateV1DetectParams{
	Q: casedev.F("Bonjour, comment allez-vous?"),
})
fmt.Println(result.Data.Detections[0][0].Language)

# Detect the language
casedev translate:v1 detect --q "Your text here"

# Then translate if needed
casedev translate:v1 translate --q "Your text here" --target en --source fr

async function routeByLanguage(text: string) {
  const result = await client.translate.v1.detect({ q: text });
  const lang = result.data.detections[0][0].language;

  switch (lang) {
    case 'en':
      return processEnglish(text);
    case 'es':
      return processSpanish(text);
    default:
      // Translate to English first
      const translated = await client.translate.v1.translate({
        q: text,
        target: 'en',
        source: lang
      });
      return processEnglish(translated.data.translations[0].translatedText);
  }
}

async def route_by_language(text: str):
    result = client.translate.v1.detect(q=text)
    lang = result.data.detections[0][0].language

    if lang == 'en':
        return process_english(text)
    elif lang == 'es':
        return process_spanish(text)
    else:
        # Translate to English first
        translated = client.translate.v1.translate(
            q=text,
            target='en',
            source=lang
        )
        return process_english(translated.data.translations[0].translated_text)

// Detect the language
detectResult, _ := client.Translate.V1.Detect(ctx, casedev.TranslateV1DetectParams{
	Q: casedev.F(text),
})
lang := detectResult.Data.Detections[0][0].Language

switch lang {
case "en":
	processEnglish(text)
case "es":
	processSpanish(text)
default:
	// Translate to English first
	translated, _ := client.Translate.V1.Translate(ctx, casedev.TranslateV1TranslateParams{
		Q:      casedev.F(text),
		Target: casedev.F("en"),
		Source: casedev.F(lang),
	})
	processEnglish(translated.Data.Translations[0].TranslatedText)
}

casedev translate:v1 detect --q "Text to check confidence for"

const result = await client.translate.v1.detect({
  q: foreignText
});

const detection = result.data.detections[0][0];

if (detection.confidence > 0.9 && detection.isReliable) {
  console.log(`Confident detection: ${detection.language}`);
} else {
  console.log('Low confidence, may need manual review');
}

result = client.translate.v1.detect(q=foreign_text)

detection = result.data.detections[0][0]

if detection.confidence > 0.9 and detection.is_reliable:
    print(f'Confident detection: {detection.language}')
else:
    print('Low confidence, may need manual review')

result, _ := client.Translate.V1.Detect(ctx, casedev.TranslateV1DetectParams{
	Q: casedev.F(foreignText),
})
detection := result.Data.Detections[0][0]

if detection.Confidence > 0.9 && detection.IsReliable {
	fmt.Printf("Confident detection: %s\n", detection.Language)
} else {
	fmt.Println("Low confidence, may need manual review")
}

# Detect each paragraph separately
casedev translate:v1 detect --q "First paragraph text"
casedev translate:v1 detect --q "Second paragraph text"

// Split document into paragraphs and detect each
const paragraphs = document.split('\n\n');

const result = await client.translate.v1.detect({
  q: paragraphs
});

const languages = new Set(
  result.data.detections.map(d => d[0].language)
);

if (languages.size > 1) {
  console.log('Mixed-language document detected');
  console.log('Languages found:', [...languages].join(', '));
}

# Split document into paragraphs and detect each
paragraphs = document.split('\n\n')

result = client.translate.v1.detect(q=paragraphs)

languages = set(d[0].language for d in result.data.detections)

if len(languages) > 1:
    print('Mixed-language document detected')
    print('Languages found:', ', '.join(languages))

// Split document into paragraphs and detect each
paragraphs := strings.Split(document, "\n\n")

result, _ := client.Translate.V1.Detect(ctx, casedev.TranslateV1DetectParams{
	Q: casedev.F(paragraphs),
})

languages := make(map[string]bool)
for _, d := range result.Data.Detections {
	languages[d[0].Language] = true
}

if len(languages) > 1 {
	fmt.Println("Mixed-language document detected")
}