Comment utiliser l'API DeepL gratuitement avec DeepLX

```html

Dans un monde de plus en plus interconnecté, le besoin de services de traduction rapides, précis et accessibles est primordial. DeepL est devenu un leader dans ce domaine, réputé pour ses traductions nuancées et naturelles, alimentées par une traduction automatique neuronale avancée. Cependant, l'accès à son API officielle s'accompagne souvent de coûts qui peuvent ne pas être réalisables pour tous les utilisateurs, développeurs ou projets à petite échelle. Entrez DeepLX, un projet open-source d'OwO-Network qui offre une alternative gratuite pour exploiter les puissantes capacités de traduction de DeepL.

Ce guide complet explorera ce qu'est DeepLX, ses avantages, comment l'installer et l'utiliser, les considérations cruciales concernant sa nature non officielle et comment il se compare aux offres officielles. Que vous soyez un développeur cherchant à intégrer la traduction dans vos applications, un amateur expérimentant des outils linguistiques ou simplement à la recherche de solutions de traduction rentables, comprendre DeepLX peut ouvrir de nouvelles possibilités.

💡

Vous voulez un excellent outil de test d'API qui génère une belle documentation d'API ?

Vous voulez une plateforme intégrée et tout-en-un pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !

button

Qu'est-ce que DeepLX ? La promesse d'une traduction gratuite et de haute qualité

À la base, DeepL est une société allemande d'IA qui fournit des services de traduction automatique reconnus pour leur précision exceptionnelle et leur capacité à saisir le contexte et les nuances linguistiques, surpassant souvent les concurrents pour de nombreuses paires de langues. Pour permettre un accès programmatique à son moteur de traduction, DeepL propose une API officielle, qui est un service payant avec différents niveaux répondant à différents volumes d'utilisation.

DeepLX, disponible sur GitHub sous OwO-Network, se présente comme une « puissante API de traduction DeepL » qui est :

Gratuite : aucun frais d'abonnement n'est requis.
Rapide : elle vise à fournir des vitesses de traduction rapides.
Sécurisée : étant open-source, son code peut être inspecté et il peut être déployé en privé sur votre propre infrastructure.
Facile à intégrer : conçue pour une intégration simple dans diverses applications.

Essentiellement, DeepLX agit comme un intermédiaire ou un proxy, permettant aux utilisateurs d'envoyer des demandes de traduction au backend de DeepL sans utiliser directement l'API officielle payante. Ceci est généralement réalisé par le serveur DeepLX qui effectue des requêtes à DeepL d'une manière qui imite la façon dont un utilisateur gratuit pourrait accéder au service (par exemple, via son interface web ou ses applications de bureau, bien que le mécanisme exact puisse varier et être sujet à changement).

Il est crucial de comprendre dès le départ que DeepLX est un outil non officiel. Il n'est ni développé ni approuvé par DeepL SE. Cette distinction a des implications importantes concernant la fiabilité, la stabilité et les conditions d'utilisation, qui seront discutées en détail plus tard. Le public cible de DeepLX comprend généralement les développeurs ayant besoin d'un accès API pour de petits projets, les chercheurs ou les utilisateurs pour lesquels les coûts de l'API officielle DeepL sont prohibitifs.

Pourquoi choisir DeepLX ? Avantages et bénéfices

Malgré son statut non officiel, DeepLX offre plusieurs avantages convaincants qui attirent les utilisateurs :

Rentabilité : c'est sans aucun doute le principal attrait. DeepLX permet aux utilisateurs d'accéder au moteur de traduction de DeepL, qui est largement reconnu pour sa qualité, sans encourir les coûts par caractère ou les frais d'abonnement associés à l'API officielle DeepL. Pour les projets avec des budgets limités ou pour un usage individuel, cela peut changer la donne.
Traductions de haute qualité : en interagissant avec le backend de DeepL, DeepLX vise à fournir des traductions de la même qualité élevée que celle pour laquelle DeepL est connu. Cela signifie des traductions plus naturelles et contextuellement précises par rapport à d'autres alternatives gratuites.
Vitesse : les utilisateurs et le projet lui-même signalent souvent des vitesses de traduction rapides. Bien que cela puisse dépendre des conditions du réseau et de la charge du serveur DeepLX, il est généralement conçu pour être performant.
Open Source et sécurité : la nature open-source de DeepLX (généralement sous licence MIT) offre une transparence. Les utilisateurs peuvent examiner la base de code pour comprendre son fonctionnement et vérifier sa sécurité. De plus, la possibilité de s'auto-héberger DeepLX sur un serveur privé signifie que le texte traduit ne doit pas nécessairement passer par des serveurs tiers (au-delà de DeepL lui-même, bien sûr), offrant ainsi un plus grand degré de confidentialité et de contrôle.
Facilité d'intégration : DeepLX est conçu pour les développeurs. Il expose généralement un point de terminaison API simple (communément http://localhost:1188/translate) auquel les applications peuvent facilement envoyer des requêtes. Cela a conduit à son intégration dans divers outils et scripts tiers.
Prise en charge de Docker : de nombreuses implémentations de DeepLX proposent des images Docker, ce qui simplifie considérablement le déploiement. Les utilisateurs peuvent rendre une instance DeepLX opérationnelle avec une seule commande Docker, sans se soucier des dépendances ou des procédures de configuration complexes.
Surmonter certaines limitations : certains outils communautaires construits autour de DeepLX, comme « DeeplxFile », visent à surmonter les limitations spécifiques du traducteur web gratuit DeepL, telles que les restrictions sur la traduction de documents volumineux ou de certains types de fichiers. En utilisant DeepLX comme backend, ces outils peuvent offrir plus de flexibilité.

Ces avantages font de DeepLX une proposition intéressante pour ceux qui ont besoin des prouesses de traduction de DeepL sans les coûts associés. Cependant, ces avantages doivent être mis en balance avec les considérations découlant de son approche non officielle.

Le statut « non officiel » : considérations critiques et inconvénients potentiels

Bien que « gratuit » et « de haute qualité » soient attrayants, il est essentiel d'avoir une compréhension claire de ce que signifie « non officiel » dans le contexte de DeepLX :

Comment cela fonctionne probablement : DeepLX n'utilise pas de clé API sanctionnée par DeepL. Au lieu de cela, il fonctionne probablement en effectuant des requêtes aux services de DeepL d'une manière qui émule un utilisateur régulier, non API, ou en tirant parti des points de terminaison que DeepL utilise pour ses propres services gratuits. Certaines sources suggèrent qu'il « se déguise pour voler l'API de DeepL » ou utilise des techniques pour imiter les en-têtes du navigateur et les paramètres TLS pour y parvenir.
Pas un produit DeepL officiel : DeepL SE ne développe, ne prend pas en charge et n'approuve pas DeepLX. Les utilisateurs ne peuvent pas s'attendre à une assistance officielle de DeepL lors de l'utilisation de DeepLX.
Potentiel d'instabilité et de non-fiabilité : étant donné que DeepLX s'appuie sur des méthodes non officielles pour accéder aux services de DeepL, il est intrinsèquement vulnérable aux modifications apportées par DeepL. Si DeepL modifie son API interne, son interface web ou ses mécanismes de limitation du débit, les instances DeepLX pourraient cesser de fonctionner ou devenir peu fiables sans avertissement. Certains utilisateurs et la documentation connexe affirment explicitement que DeepLX peut être « instable ».
Limitation du débit (erreurs HTTP 429) : il s'agit d'un problème courant et important. DeepL utilise des mesures pour empêcher l'abus de ses services gratuits. Si une instance DeepLX (ou l'adresse IP sur laquelle elle s'exécute) effectue trop de requêtes en peu de temps, DeepL la limitera ou la bloquera probablement, ce qui entraînera des erreurs « 429 Too Many Requests ». Il n'existe souvent aucune solution simple du côté de DeepLX autre que de réduire la fréquence des requêtes (par exemple, en ajoutant des délais entre les appels).
Ensemble de fonctionnalités limité par rapport à l'API officielle : l'API officielle DeepL offre une gamme de fonctionnalités, notamment la prise en charge des glossaires, les paramètres de formalité, la gestion XML, etc. Les implémentations de DeepLX peuvent ne pas prendre en charge toutes ces fonctionnalités et se concentrent souvent principalement sur la fonctionnalité principale /translate.
Considérations éthiques et juridiques : l'utilisation de services d'une manière qui contourne leurs méthodes d'accès prévues peut soulever des questions éthiques. Les utilisateurs doivent également être conscients des conditions d'utilisation de DeepL. Bien que DeepLX lui-même soit un logiciel open-source, sa méthode d'accès aux services de traduction propriétaires de DeepL opère dans une zone grise. Cet article vise à informer sur l'existence et la fonctionnalité de l'outil telles que décrites par ses utilisateurs et développeurs ; il est de la responsabilité de l'utilisateur de s'assurer qu'il est conforme à toutes les conditions et réglementations pertinentes.

Les utilisateurs doivent aborder DeepLX avec une certaine prudence, en comprenant qu'il pourrait ne pas convenir aux applications critiques pour la mission où la disponibilité garantie et l'assistance officielle sont nécessaires. Il est préférable dans les scénarios où les temps d'arrêt occasionnels ou la nécessité de dépannage sont des compromis acceptables pour un accès gratuit.

Premiers pas : installation et configuration de DeepLX

La configuration de DeepLX est généralement simple, surtout si vous connaissez Docker ou si vous exécutez des binaires précompilés. Voici les méthodes courantes :

Conditions préalables

Compréhension de base de l'interface de ligne de commande (CLI).
Docker installé, si vous choisissez la méthode Docker.
Accès Internet pour télécharger des fichiers.

Méthode 1 : Utilisation de Docker (recommandée pour la simplicité)

Docker est souvent le moyen le plus simple de faire fonctionner DeepLX, car il regroupe toutes les dépendances et configurations.

Trouver l'image Docker : OwO-Network ou les développeurs contribuant à DeepLX fournissent généralement des images Docker sur Docker Hub. Vous pouvez rechercher deeplx sur Docker Hub ou rechercher des instructions sur le référentiel GitHub officiel de DeepLX. Les images courantes peuvent être nommées comme owonetwork/deeplx ou similaire.
Extraire l'image : Ouvrez votre terminal et exécutez :

docker pull <image_name>:<tag>

(Remplacez <image_name>:<tag> par le nom réel de l'image).

Exécuter le conteneur Docker :

docker run -d -p 1188:1188 --name my-deeplx <image_name>:<tag>

-d : exécute le conteneur en mode détaché (en arrière-plan).
-p 1188:1188 : mappe le port 1188 sur votre machine hôte vers le port 1188 dans le conteneur. DeepLX écoute généralement sur le port 1188 par défaut. Vous pouvez modifier le port hôte si nécessaire (par exemple, -p 8080:1188).
--name my-deeplx : attribue un nom mémorable à votre conteneur.

Vérifier : vous pouvez vérifier si le conteneur est en cours d'exécution avec docker ps. Le service DeepLX doit maintenant être accessible à l'adresse http://localhost:1188.

Méthode 2 : Téléchargement de binaires précompilés

De nombreux projets open-source fournissent des exécutables précompilés pour divers systèmes d'exploitation.

Accéder aux versions GitHub : accédez au référentiel GitHub officiel de DeepLX (OwO-Network/DeepLX) et recherchez la section « Versions ».
Télécharger le binaire correct : vous trouverez des binaires pour différents systèmes d'exploitation et architectures (par exemple, deeplx_windows_amd64.exe, deeplx_linux_amd64, deeplx_darwin_amd64). Téléchargez celui qui correspond à votre système.
Le rendre exécutable (Linux/macOS) :

chmod +x /path/to/your/deeplx_binary

Exécuter le binaire :

./path/to/your/deeplx_binary [options]

Le binaire peut prendre en charge des indicateurs de ligne de commande pour la configuration (par exemple, spécifier un port avec -p <port_number> ou un jeton pour sécuriser l'instance DeepLX elle-même, bien que cela soit distinct d'une clé API DeepL). Reportez-vous à la documentation du projet pour connaître les options disponibles.

Pare-feu : assurez-vous que le pare-feu de votre système autorise les connexions entrantes sur le port sur lequel DeepLX écoute (par défaut 1188) si vous avez l'intention d'y accéder à partir d'autres appareils de votre réseau.

Méthode 3 : Compilation à partir de la source (pour les utilisateurs avancés)

Si vous préférez le compiler vous-même ou si vous souhaitez les dernières modifications non publiées :

Installer les dépendances de compilation : DeepLX est souvent écrit dans des langages comme Go ou Rust. Vous aurez besoin du compilateur et de la chaîne d'outils respectifs installés (par exemple, l'environnement du langage de programmation Go). Consultez le référentiel GitHub pour les instructions de compilation.
Cloner le référentiel :

git clone [https://github.com/OwO-Network/DeepLX.git](https://github.com/OwO-Network/DeepLX.git)
cd DeepLX

Compiler le projet : suivez les commandes de compilation spécifiées dans le README.md du référentiel ou les scripts de compilation (par exemple, go build . ou cargo build --release).
Exécuter le binaire compilé : l'exécutable résultant peut ensuite être exécuté comme décrit dans la méthode 2.

Configuration initiale (côté serveur)

DeepLX lui-même est souvent conçu pour s'exécuter avec une configuration minimale. La principale chose à noter est le port sur lequel il écoute (par défaut 1188). Certaines versions ou forks peuvent permettre de définir un jeton d'accès via des arguments de ligne de commande ou des variables d'environnement (par exemple, -token YOUR_SECRET_TOKEN). Ce jeton devrait ensuite être fourni par les clients pour utiliser votre instance DeepLX, ajoutant ainsi une couche de sécurité si votre point de terminaison DeepLX est exposé.

Une fois en cours d'exécution, votre instance DeepLX doit être prête à recevoir les demandes de traduction.

Comment utiliser DeepLX : effectuer des demandes de traduction

Une fois votre instance DeepLX opérationnelle (par exemple, à l'adresse http://localhost:1188), vous pouvez commencer à envoyer des demandes de traduction à son point de terminaison API, qui est généralement /translate.

Point de terminaison API

http://<your_deeplx_host_or_ip>:<port>/translate
(par exemple, http://localhost:1188/translate si vous l'exécutez localement sur le port par défaut)

Structure d'appel d'API de base

Méthode : POST
En-têtes :
Content-Type: application/json
Corps : une charge utile JSON contenant le texte à traduire et les paramètres de langue.

Paramètres clés dans le corps JSON

text (chaîne ou tableau de chaînes) : le texte que vous souhaitez traduire.
source_lang (chaîne, facultatif) : le code de langue du texte source (par exemple, « EN », « DE », « FR »). S'il est omis ou défini sur « auto », DeepLX (via DeepL) tentera de détecter la langue source.
target_lang (chaîne, obligatoire) : le code de langue dans lequel vous souhaitez traduire le texte (par exemple, « EN-US », « EN-GB », « DE », « FR », « ZH », « JA »).
D'autres paramètres peuvent être pris en charge en fonction de la version de DeepLX, tels que split_sentences, preserve_formatting, formality. Consultez la documentation du projet DeepLX spécifique si elle est disponible.

Exemple utilisant `curl`

Pour traduire « Hello, world ! » de l'anglais vers l'allemand :

curl -X POST http://localhost:1188/translate \
     -H "Content-Type: application/json" \
     -d '{
           "text": "Hello, world!",
           "source_lang": "EN",
           "target_lang": "DE"
         }'

Interprétation de la réponse

Réponse réussie (par exemple, HTTP 200 OK) : la réponse sera un objet JSON contenant généralement :

code : un code d'état (par exemple, 200 pour la réussite).
id : un ID de requête.
data : le texte traduit. Si plusieurs textes ont été envoyés, il peut s'agir d'un tableau de traductions.
source_lang : la langue source détectée (si « auto » a été utilisé ou si elle a été fournie).
target_lang : la langue cible.
alternatives (facultatif) : certaines interfaces DeepL fournissent des traductions alternatives ; DeepLX pourrait également les inclure.

Exemple de structure de réponse réussie : JSON

{
    "code": 200,
    "id": 1678886400000,
    "data": "Hallo, Welt!",
    "source_lang": "EN",
    "target_lang": "DE",
    "alternatives": [
        "Hallo Welt!"
    ]
}

Réponses d'erreur :

HTTP 400 Bad Request : charge utile JSON non valide, paramètres requis manquants ou codes de langue non valides.
HTTP 429 Too Many Requests : vous êtes limité. Ralentissez vos requêtes.
HTTP 500 Internal Server Error (ou similaire 5xx) : un problème du côté du serveur DeepLX ou une erreur inattendue de la part de DeepL. Vérifiez les journaux de votre serveur DeepLX.

Utilisation de DeepLX avec des langages de programmation (exemples conceptuels)

Python (en utilisant la bibliothèque requests) : Python

import requests
import json

deeplx_url = "http://localhost:1188/translate"
text_to_translate = "The quick brown fox jumps over the lazy dog."

payload = {
    "text": text_to_translate,
    "source_lang": "EN",
    "target_lang": "ES"  # Translate to Spanish
}

headers = {
    "Content-Type": "application/json"
}

try:
    response = requests.post(deeplx_url, data=json.dumps(payload), headers=headers)
    response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
    
    translation_data = response.json()
    
    if translation_data.get("code") == 200:
        print(f"Original: {text_to_translate}")
        print(f"Translated: {translation_data.get('data')}")
    else:
        print(f"Error from DeepLX: {translation_data.get('message', 'Unknown error')}")

except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")
except json.JSONDecodeError:
    print("Failed to decode JSON response.")

JavaScript (en utilisant l'API Workspace dans un navigateur ou un environnement Node.js) : JavaScript

async function translateText(text, targetLang, sourceLang = "auto") {
    const deeplxUrl = "http://localhost:1188/translate"; // Adjust if your DeepLX is elsewhere
    const payload = {
        text: text,
        source_lang: sourceLang,
        target_lang: targetLang
    };

    try {
        const response = await fetch(deeplxUrl, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(payload)
        });

        if (!response.ok) {
            // Try to get error message from DeepLX if possible
            let errorMsg = `HTTP error! status: ${response.status}`;
            try {
                const errorData = await response.json();
                errorMsg = errorData.message || JSON.stringify(errorData);
            } catch (e) { /* ignore if response is not json */ }
            throw new Error(errorMsg);
        }

        const translationData = await response.json();

        if (translationData.code === 200) {
            return translationData.data;
        } else {
            throw new Error(translationData.message || `DeepLX API error code: ${translationData.code}`);
        }
    } catch (error) {
        console.error("Translation failed:", error);
        return null;
    }
}

// Example usage:
(async () => {
    const translatedText = await translateText("Welcome to the world of AI.", "JA"); // To Japanese
    if (translatedText) {
        console.log(`Translated: ${translatedText}`);
    }
})();

N'oubliez pas d'adapter deeplx_url si votre instance DeepLX ne s'exécute pas sur localhost:1188.

Intégration de DeepLX avec des applications

L'un des principaux cas d'utilisation de DeepLX est d'alimenter les fonctionnalités de traduction au sein d'autres applications sans encourir les coûts de l'API officielle. Plusieurs outils et projets ont déjà démontré des intégrations :

Bots Telegram : le DeepLX-Bot en est un excellent exemple, conçu pour traduire automatiquement les messages dans les chats Telegram à l'aide d'un backend DeepLX.
Outils de traduction vidéo : pyVideoTrans est mentionné comme un outil qui peut utiliser une instance DeepLX déployée localement pour traduire les sous-titres vidéo.
Éditeurs de sous-titres : SubtitleEdit a eu des discussions ou des intégrations pour l'utilisation de DeepLX, permettant aux utilisateurs de traduire des fichiers de sous-titres.
Utilitaires de traduction de fichiers : DeeplxFile est un outil conçu pour traduire des fichiers, en particulier des fichiers volumineux ou des documents Excel complexes, en tirant parti de DeepLX et en surmontant potentiellement les limitations de l'interface web gratuite de DeepL ou du niveau d'API gratuit officiel.

Approche générale de l'intégration

Configurez votre instance DeepLX : assurez-vous que votre serveur DeepLX est en cours d'exécution et accessible depuis l'application qui l'utilisera.
Identifier les paramètres de configuration : dans l'application avec laquelle vous souhaitez intégrer, recherchez les paramètres liés aux services de traduction ou à l'API DeepL.
Pointer vers votre point de terminaison DeepLX : au lieu d'une URL d'API DeepL officielle (comme https://api-free.deepl.com/v2/translate ou https://api.deepl.com/v2/translate), vous saisirez généralement l'adresse de votre serveur DeepLX (par exemple, http://localhost:1188/translate ou http://your-server-ip:1188/translate).
Gestion des clés API :

La plupart des applications conçues pour l'API DeepL officielle auront un champ pour une « clé API » ou une « clé d'authentification ».
DeepLX lui-même ne nécessite généralement pas de clé API DeepL. Si l'application nécessite qu'un champ de clé API soit rempli, vous pourrez peut-être saisir une valeur factice (par exemple, « deeplx », « none » ou une chaîne aléatoire).
Cependant, si votre instance DeepLX est configurée avec son propre jeton d'accès pour la sécurité (comme discuté dans la section de configuration), l'application aurait besoin d'un moyen d'envoyer ce jeton, peut-être en tant qu'en-tête personnalisé ou dans le cadre de l'URL si l'application et DeepLX le prennent en charge. Ceci est moins courant pour les intégrations DeepL standard.

Tester minutieusement : après la configuration, testez la fonctionnalité de traduction dans l'application pour vous assurer qu'elle fonctionne correctement avec votre backend DeepLX.

La facilité d'intégration dépend en grande partie de la flexibilité de la configuration du service de traduction de l'application cible.

Considérations avancées et meilleures pratiques

Pour tirer le meilleur parti de DeepLX et atténuer certains de ses problèmes potentiels, tenez compte des éléments suivants :

Gestion des limites de débit (erreurs 429) :
Si vous créez une application qui utilise DeepLX, implémentez une logique de nouvelle tentative avec repli exponentiel pour les erreurs 429. Cela signifie que si une requête échoue en raison d'une limitation du débit, votre application attendra une courte période, puis réessayera, en augmentant le temps d'attente après chaque échec ultérieur.
Introduisez des délais entre les requêtes consécutives pour éviter d'atteindre les limites de débit de DeepL via votre instance DeepLX.
Si possible, répartissez les requêtes sur plusieurs instances DeepLX ou adresses IP, bien que cela ajoute de la complexité.
Gestion robuste des erreurs : concevez vos applications clientes pour gérer avec élégance les erreurs potentielles de DeepLX. Cela inclut non seulement les erreurs 429, mais également les erreurs de serveur 5xx, les problèmes de réseau ou les formats de réponse inattendus. Fournissez des commentaires informatifs aux utilisateurs en cas d'échec d'une traduction.
Sécurité de votre instance DeepLX :
Si votre instance DeepLX est exposée à un réseau (en particulier à Internet), sécurisez-la.
Exécutez-la derrière un proxy inverse (comme Nginx ou Caddy) qui peut fournir un cryptage SSL/TLS, une authentification (par exemple, HTTP Basic Auth) et sa propre limitation du débit.
Utilisez des règles de pare-feu pour restreindre l'accès aux adresses IP de confiance.
Si votre version de DeepLX le prend en charge, configurez un jeton d'accès pour le service DeepLX lui-même.
Surveillance de votre instance : gardez un œil sur les performances de votre serveur DeepLX :
Surveillez l'utilisation du processeur et de la mémoire.
Vérifiez les journaux régulièrement pour détecter les erreurs ou les avertissements, qui peuvent fournir des informations sur des problèmes tels que la limitation fréquente du débit ou d'autres problèmes.
Rester à jour : vérifiez périodiquement le référentiel GitHub DeepLX (et tous les forks que vous pourriez utiliser) pour :
Nouvelles versions : celles-ci peuvent inclure des corrections de bogues, des améliorations des performances ou des adaptations aux modifications des services de DeepL.
Problèmes signalés : voyez si d'autres utilisateurs rencontrent des problèmes similaires et si des solutions ou des solutions de contournement ont été publiées.
Avoir un plan de secours : étant donné la nature « non officielle » et potentiellement instable de DeepLX, si une traduction fiable est essentielle, envisagez d'avoir une stratégie de secours. Cela pourrait impliquer de passer à un service de traduction différent (peut-être payant) si DeepLX devient indisponible. La documentation de pyVideoTrans conseille même : « Si vous rencontrez des erreurs... après avoir confirmé que le déploiement est correct, veuillez passer à d'autres canaux de traduction. »

En étant proactif, vous pouvez améliorer la stabilité et l'utilité de votre configuration DeepLX.

Dépannage des problèmes courants de DeepLX

Rencontrer des problèmes est possible étant donné la nature de DeepLX. Voici quelques problèmes courants et comment les aborder :

Problème : erreur `429 Too Many Requests`

Cause : votre instance DeepLX (ou son IP) envoie trop de requêtes à DeepL trop rapidement.
Solution :
Réduisez la fréquence de vos demandes de traduction à partir des applications clientes. Implémentez des délais.
Si vous contrôlez le serveur DeepLX et qu'il est attaqué par de nombreux clients, envisagez une limitation du débit côté client ou la répartition de la charge.
Attendez un certain temps, car les limites de débit sont souvent temporaires.
Le redémarrage de votre instance DeepLX peut parfois aider si elle acquiert une nouvelle session ou si le blocage de DeepL est de courte durée, mais ce n'est pas une solution garantie.
Envisagez