Détection de la langue

Discuse identifie la langue d’un message afin que vous puissiez appliquer les bonnes règles de modération avant d’agir. Envoyez le texte à POST https://api.discuse.com/api/v2/check avec check_language activé, puis lisez le code de langue détecté dans results.language.language. Ajoutez expected_language pour signaler les contenus qui ne sont pas dans la langue requise.

À quoi sert la détection de la langue ?

Détecter la langue en amont vous permet de :

Appliquer des seuils de modération propres à chaque langue
Orienter le contenu vers les bons modérateurs ou la bonne équipe d’assistance
Faire respecter une politique linguistique au sein de la communauté
Filtrer ou localiser les fils de contenu par langue

Comment détecter une langue ?

curl -X POST https://api.discuse.com/api/v2/check \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_API_KEY" \
  -d '{
    "content": {
      "text": "Bonjour, comment allez-vous aujourd'\''hui?"
    },
    "settings": {
      "check_language": true
    }
  }'

Format de la réponse

{
  "has_violations": false,
  "cached": false,
  "results": {
    "language": {
      "language": "fr",
      "confidence": 0.99,
      "hit": false
    }
  }
}

Le code de langue détecté se trouve dans results.language.language. Lorsque l’application de expected_language est activée, detected et expected sont également renseignés (voir ci-dessous).

Quels champs le résultat de langue renvoie-t-il ?

Champ	Type	Signification
`language`	string	Code de langue détecté (par ex. `en`, `fr`, `es`)
`confidence`	number	Niveau de confiance de la détection (0.0–1.0)
`expected`	string	Code de langue imposé, lorsque `expected_language` est défini
`detected`	string	Code détecté (alias de `language`, renseigné lors de l’application de la règle)
`hit`	bool	Vrai lorsque la langue détectée ne correspond pas à `expected`
`delete_only`	bool	Lorsque la valeur est vraie, le message doit être supprimé sans autre sanction
`error`	string	Présent uniquement en cas d’échec de la détection

Quelles langues sont prises en charge ?

Discuse renvoie des codes de langue de style ISO. Les langues couramment détectées incluent :

Code	Langue	Code	Langue
`en`	Anglais	`de`	Allemand
`es`	Espagnol	`fr`	Français
`it`	Italien	`pt`	Portugais
`nl`	Néerlandais	`pl`	Polonais
`ru`	Russe	`uk`	Ukrainien
`zh`	Chinois	`ja`	Japonais
`ko`	Coréen	`ar`	Arabe
`hi`	Hindi	`tr`	Turc

Lisez directement la valeur de results.language.language plutôt que de coder en dur une liste fixe.

Comment imposer une langue spécifique ?

Définissez expected_language sur le code requis. Lorsque la langue détectée est différente, language.hit vaut true et expected/detected sont renseignés :

Requête :

{
  "content": { "text": "Hola, cómo estás?" },
  "settings": {
    "check_language": true,
    "expected_language": "en"
  }
}

Réponse :

{
  "has_violations": true,
  "message": "Content is not in expected language",
  "results": {
    "hits": true,
    "language": {
      "language": "es",
      "detected": "es",
      "expected": "en",
      "confidence": 0.97,
      "hit": true
    }
  }
}

Cas d’utilisation

Forums uniquement en anglais

async function validatePost(post) {
  const result = await fetch('https://api.discuse.com/api/v2/check', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': process.env.DISCUSE_API_KEY
    },
    body: JSON.stringify({
      content: { text: post.content },
      settings: { check_language: true, expected_language: 'en' }
    })
  }).then(r => r.json());

  if (result.results.language.hit) {
    return {
      approved: false,
      reason: 'Posts must be in English',
      detected_language: result.results.language.language
    };
  }
  return { approved: true };
}

Routage multilingue

async function routeContent(content) {
  const result = await checkLanguage(content.text);
  const language = result.results.language.language;

  const moderatorQueue = {
    en: 'english-moderation',
    es: 'spanish-moderation',
    fr: 'french-moderation',
    de: 'german-moderation',
    default: 'general-moderation'
  };

  const queue = moderatorQueue[language] || moderatorQueue.default;
  await addToQueue(queue, content);
  return { queued: true, language };
}

Combinaison avec la modération de contenu

Exécutez la détection de la langue avec l’analyse du sentiment et la détection du spam dans une seule requête :

{
  "content": {
    "text": "User message in any language"
  },
  "settings": {
    "check_language": true,
    "check_sentiment": true,
    "check_spam": true
  }
}

La langue détectée peut ensuite déterminer vos seuils de sentiment par langue :

const LANGUAGE_THRESHOLDS = {
  en: { toxicity: 0.7, profanity: 0.6 },
  de: { toxicity: 0.6, profanity: 0.5 },
  es: { toxicity: 0.7, profanity: 0.7 },
  default: { toxicity: 0.7, profanity: 0.6 }
};

async function moderateContent(text) {
  const result = await checkText(text); // check_language + check_sentiment
  const language = result.results.language.language;
  const thresholds = LANGUAGE_THRESHOLDS[language] || LANGUAGE_THRESHOLDS.default;
  const sentiment = result.results.sentiment;

  if (sentiment.toxicity > thresholds.toxicity) {
    return { action: 'block', reason: 'toxic_content' };
  }
  if (sentiment.profanity > thresholds.profanity) {
    return { action: 'flag', reason: 'profanity' };
  }
  return { action: 'allow' };
}

Bonnes pratiques

Tenir compte des textes courts

La détection est moins fiable sur les chaînes très courtes. Ignorez la vérification en dessous d’une longueur minimale :

async function smartLanguageCheck(text) {
  if (text.length < 20) {
    return { language: 'unknown', confidence: 0 };
  }
  const result = await checkLanguage(text);
  return result.results.language;
}

Mettre les résultats en cache

async function getLanguageWithCache(text, contentId) {
  const cached = await cache.get(`lang:${contentId}`);
  if (cached) return JSON.parse(cached);

  const result = await checkLanguage(text);
  const language = result.results.language;
  await cache.set(`lang:${contentId}`, JSON.stringify(language), 'EX', 3600);
  return language;
}

Limites d’utilisation

La détection de la langue est décomptée de votre quota d’analyse de texte :

Offre	Analyses mensuelles
Basic	1,000
Gold	5,000
Platinum	15,000
Ultimate	30,000

Les réponses mises en cache ne sont pas décomptées de votre quota.

Exemples d’intégration

Node.js

const checkLanguage = async (text, expectedLanguage = null) => {
  const settings = { check_language: true };
  if (expectedLanguage) settings.expected_language = expectedLanguage;

  const response = await fetch('https://api.discuse.com/api/v2/check', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': process.env.DISCUSE_API_KEY
    },
    body: JSON.stringify({ content: { text }, settings })
  });

  return response.json();
};

Python

import os
import requests

def check_language(text, expected_language=None):
    settings = {'check_language': True}
    if expected_language:
        settings['expected_language'] = expected_language

    response = requests.post(
        'https://api.discuse.com/api/v2/check',
        headers={
            'Content-Type': 'application/json',
            'X-API-Key': os.environ['DISCUSE_API_KEY']
        },
        json={'content': {'text': text}, 'settings': settings}
    )
    return response.json()

Prochaines étapes

Analyse de texte - combiner avec l’analyse du sentiment et la détection du spam
Détection du spam - classer les contenus promotionnels et frauduleux
Guide de démarrage rapide - obtenir votre première clé API