Blog

Como Usar a API DeepL Grátis com DeepLX

Mark Ponomarev

Mark Ponomarev

21 maio 2025

Como Usar a API DeepL Grátis com DeepLX

Em um mundo cada vez mais interconectado, a necessidade de serviços de tradução rápidos, precisos e acessíveis é fundamental. A DeepL emergiu como líder nesse espaço, conhecida por suas traduções com nuances e sonoridade natural, impulsionadas por tradução automática neural avançada. No entanto, o acesso à sua API oficial geralmente vem com custos que podem não ser viáveis para todos os usuários, desenvolvedores ou projetos de pequena escala. Surge o DeepLX, um projeto de código aberto da OwO-Network que oferece um caminho alternativo gratuito para aproveitar as poderosas capacidades de tradução da DeepL.

Este guia abrangente abordará o que é o DeepLX, seus benefícios, como instalá-lo e usá-lo, as considerações cruciais sobre sua natureza não oficial e como ele se compara às ofertas oficiais. Seja você um desenvolvedor buscando integrar tradução em suas aplicações, um entusiasta experimentando ferramentas de linguagem ou simplesmente procurando soluções de tradução econômicas, entender o DeepLX pode abrir novas possibilidades.

💡
Quer uma ótima ferramenta de Teste de API que gera Documentação de API linda?

Quer uma plataforma integrada, Tudo-em-Um para sua Equipe de Desenvolvedores trabalhar junta com máxima produtividade?

Apidog entrega todas as suas demandas, e substitui o Postman por um preço muito mais acessível!
botão

O que é DeepLX? A Promessa de Tradução Gratuita e de Alta Qualidade

Em sua essência, a DeepL é uma empresa alemã de IA que fornece serviços de tradução automática conhecidos por sua precisão excepcional e capacidade de capturar contexto e nuances linguísticas, frequentemente superando concorrentes para muitos pares de idiomas. Para permitir acesso programático ao seu mecanismo de tradução, a DeepL oferece uma API oficial, que é um serviço pago com vários níveis para diferentes volumes de uso.

O DeepLX, encontrado no GitHub sob a OwO-Network, se apresenta como uma "Poderosa API de Tradução DeepL" que é:

Essencialmente, o DeepLX atua como um intermediário ou proxy, permitindo que os usuários enviem solicitações de tradução para o backend da DeepL sem usar diretamente a API paga oficial. Isso geralmente é alcançado pelo servidor DeepLX fazendo solicitações à DeepL de uma maneira que imita como um usuário gratuito acessaria o serviço (por exemplo, através de sua interface web ou aplicativos de desktop, embora o mecanismo exato possa variar e estar sujeito a alterações).

É crucial entender desde o início que o DeepLX é uma ferramenta não oficial. Não é desenvolvida ou endossada pela DeepL SE. Essa distinção acarreta implicações importantes em relação à confiabilidade, estabilidade e termos de serviço, que serão discutidas em detalhes posteriormente. O público-alvo do DeepLX geralmente inclui desenvolvedores que precisam de acesso à API para projetos menores, pesquisadores ou usuários para quem os custos da API oficial da DeepL são proibitivos.

Por que Escolher DeepLX? Benefícios e Vantagens

Apesar de seu status não oficial, o DeepLX oferece várias vantagens atraentes que atraem usuários:

Esses benefícios tornam o DeepLX uma proposta atraente para aqueles que precisam da capacidade de tradução da DeepL sem os custos associados. No entanto, essas vantagens devem ser ponderadas em relação às considerações decorrentes de sua abordagem não oficial.

O Status "Não Oficial": Considerações Críticas e Desvantagens Potenciais

Embora "gratuito" e "alta qualidade" sejam atraentes, é vital ter uma compreensão clara do que "não oficial" significa no contexto do DeepLX:

Os usuários devem abordar o DeepLX com um certo grau de cautela, entendendo que ele pode não ser adequado para aplicações de missão crítica onde tempo de atividade garantido e suporte oficial são necessários. É melhor para cenários onde tempo de inatividade ocasional ou a necessidade de solução de problemas são compensações aceitáveis para o acesso gratuito.

Primeiros Passos: Instalação e Configuração do DeepLX

Configurar o DeepLX é geralmente simples, especialmente se você estiver familiarizado com Docker ou com a execução de binários pré-compilados. Aqui estão os métodos comuns:

Pré-requisitos

Método 1: Usando Docker (Recomendado pela Simplicidade)

Docker é frequentemente a maneira mais fácil de colocar o DeepLX em funcionamento, pois empacota todas as dependências e configurações.

  1. Encontre a Imagem Docker: A OwO-Network ou desenvolvedores que contribuem para o DeepLX geralmente fornecem imagens Docker no Docker Hub. Você pode pesquisar por deeplx no Docker Hub ou procurar instruções no repositório oficial do DeepLX no GitHub. Imagens comuns podem ter nomes como owonetwork/deeplx ou similar.
  2. Baixe a Imagem: Abra seu terminal e execute:
docker pull <image_name>:<tag>

(Substitua <image_name>:<tag> pelo nome real da imagem).

  1. Execute o Contêiner Docker:
docker run -d -p 1188:1188 --name my-deeplx <image_name>:<tag>
  1. Verifique: Você pode verificar se o contêiner está rodando com docker ps. O serviço DeepLX agora deve estar acessível em http://localhost:1188.

Método 2: Baixando Binários Pré-compilados

Muitos projetos de código aberto fornecem executáveis pré-compilados para vários sistemas operacionais.

  1. Vá para as Releases do GitHub: Navegue até o repositório oficial do DeepLX no GitHub (OwO-Network/DeepLX) e procure a seção "Releases".
  2. Baixe o Binário Correto: Você encontrará binários para diferentes sistemas operacionais e arquiteturas (por exemplo, deeplx_windows_amd64.exe, deeplx_linux_amd64, deeplx_darwin_amd64). Baixe aquele que corresponde ao seu sistema.
  3. Torne-o Executável (Linux/macOS):
chmod +x /path/to/your/deeplx_binary
  1. Execute o Binário:
./path/to/your/deeplx_binary [options]

O binário pode suportar flags de linha de comando para configuração (por exemplo, especificando uma porta com -p <port_number> ou um token para proteger a própria instância DeepLX, embora isso seja distinto de uma chave de API DeepL). Consulte a documentação do projeto para opções disponíveis.

  1. Firewall: Garanta que o firewall do seu sistema permita conexões de entrada na porta em que o DeepLX está escutando (padrão 1188), se você pretende acessá-lo de outros dispositivos em sua rede.

Método 3: Compilando a Partir do Código Fonte (Para Usuários Avançados)

Se você preferir compilá-lo você mesmo ou quiser as últimas mudanças não lançadas:

  1. Instale as Dependências de Build: O DeepLX é frequentemente escrito em linguagens como Go ou Rust. Você precisará do compilador e toolchain respectivos instalados (por exemplo, ambiente da linguagem de programação Go). Verifique o repositório GitHub para instruções de build.
  2. Clone o Repositório:
git clone [https://github.com/OwO-Network/DeepLX.git](https://github.com/OwO-Network/DeepLX.git)
cd DeepLX
  1. Compile o Projeto: Siga os comandos de build especificados no README.md do repositório ou scripts de build (por exemplo, go build . ou cargo build --release).
  2. Execute o Binário Compilado: O executável resultante pode então ser executado conforme descrito no Método 2.

Configuração Inicial (Lado do Servidor)

O DeepLX em si é frequentemente projetado para rodar com configuração mínima. O principal a notar é a porta em que ele escuta (padrão 1188). Algumas versões ou forks podem permitir a configuração de um token de acesso via argumentos de linha de comando ou variáveis de ambiente (por exemplo, -token YOUR_SECRET_TOKEN). Este token precisaria então ser fornecido pelos clientes para usar sua instância DeepLX, adicionando uma camada de segurança se seu endpoint DeepLX estiver exposto.

Uma vez em execução, sua instância DeepLX deve estar pronta para receber solicitações de tradução.

Como Usar o DeepLX: Fazendo Solicitações de Tradução

Uma vez que sua instância DeepLX esteja em funcionamento (por exemplo, em http://localhost:1188), você pode começar a enviar solicitações de tradução para seu endpoint de API, que é tipicamente /translate.

Endpoint da API

http://<seu_host_ou_ip_deeplx>:<porta>/translate
(por exemplo, http://localhost:1188/translate se rodando localmente na porta padrão)

Estrutura Básica da Chamada de API

Parâmetros Chave no Corpo JSON

Exemplo usando curl

Para traduzir "Hello, world!" de Inglês para Alemão:

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

Interpretando a Resposta

Resposta Bem-sucedida (por exemplo, HTTP 200 OK): A resposta será um objeto JSON tipicamente contendo:

Exemplo de estrutura de resposta bem-sucedida:JSON

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

Respostas de Erro:

Usando DeepLX com Linguagens de Programação (Exemplos Conceituais)

Python (usando a biblioteca 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"  # Traduzir para Espanhol
}

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

try:
    response = requests.post(deeplx_url, data=json.dumps(payload), headers=headers)
    response.raise_for_status()  # Levanta uma exceção para códigos de status ruins (4xx ou 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 (usando a API fetch em um navegador ou ambiente Node.js):JavaScript

async function translateText(text, targetLang, sourceLang = "auto") {
    const deeplxUrl = "http://localhost:1188/translate"; // Ajuste se seu DeepLX estiver em outro lugar
    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) {
            // Tenta obter mensagem de erro do DeepLX, se possível
            let errorMsg = `HTTP error! status: ${response.status}`;
            try {
                const errorData = await response.json();
                errorMsg = errorData.message || JSON.stringify(errorData);
            } catch (e) { /* ignora se a resposta não for 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;
    }
}

// Exemplo de uso:
(async () => {
    const translatedText = await translateText("Welcome to the world of AI.", "JA"); // Para Japonês
    if (translatedText) {
        console.log(`Translated: ${translatedText}`);
    }
})();

Lembre-se de adaptar a deeplx_url se sua instância DeepLX não estiver rodando em localhost:1188.

Integrando DeepLX com Aplicações

Um dos principais casos de uso para o DeepLX é alimentar recursos de tradução dentro de outras aplicações sem incorrer nos custos da API oficial. Várias ferramentas e projetos já demonstraram integrações:

Abordagem Geral para Integração

  1. Configure sua Instância DeepLX: Garanta que seu servidor DeepLX esteja rodando e acessível a partir da aplicação que o utilizará.
  2. Identifique as Configurações: Na aplicação que você deseja integrar, procure configurações relacionadas a serviços de tradução ou API da DeepL.
  3. Aponte para seu Endpoint DeepLX: Em vez de uma URL de API oficial da DeepL (como https://api-free.deepl.com/v2/translate ou https://api.deepl.com/v2/translate), você tipicamente inserirá o endereço do seu servidor DeepLX (por exemplo, http://localhost:1188/translate ou http://seu-ip-servidor:1188/translate).
  4. Tratamento da Chave de API:
  1. Teste Exaustivamente: Após a configuração, teste a funcionalidade de tradução dentro da aplicação para garantir que está funcionando corretamente com seu backend DeepLX.

A facilidade de integração depende em grande parte da flexibilidade da configuração do serviço de tradução da aplicação alvo.

Considerações Avançadas e Melhores Práticas

Para aproveitar ao máximo o DeepLX e mitigar alguns de seus problemas potenciais, considere o seguinte:

Sendo proativo, você pode melhorar a estabilidade e a utilidade da sua configuração DeepLX.

Solução de Problemas Comuns do DeepLX

Encontrar problemas é possível dada a natureza do DeepLX. Aqui estão alguns problemas comuns e como abordá-los:

Problema: Erro 429 Too Many Requests

Problema: Instância DeepLX Não Inicia ou Trava

Problema: Traduções Incorretas, Falhando ou Retornando Resultados Inesperados

Problema: Erros de Conexão de Rede (por exemplo, "Connection refused," "Timeout")

A solução de problemas do DeepLX frequentemente envolve verificar logs, verificar configurações e ficar de olho nas discussões da comunidade sobre o projeto.

DeepLX vs. API Oficial da DeepL: Uma Comparação Rápida

RecursoDeepLX (via OwO-Network)API Oficial DeepL (Camada Gratuita)API Oficial DeepL (Pro/Pago)
CustoGratuitoGratuitoPago (assinatura/por caractere)
FonteNão oficial, código abertoOficialOficial
EstabilidadePotencialmente instável, pode quebrarGeralmente estávelAlta estabilidade, SLA pode ser oferecido
Limites de TaxaPropenso a erros 429, menos previsívelLimite de 500.000 caracteres/mêsLimites maiores/customizáveis, pagamento por uso

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar