🇪🇺 Static IP for DeepL — Translation API Proxy

🇪🇺 Static IP for DeepL

Translating content with the DeepL API from containers, serverless, or cloud platforms? Your dynamic outbound IP changes on every deploy. Route translation, text rewriting, and glossary calls through a dedicated static EU IP for stable, GDPR-compliant localization workflows.

translate.py

import requests

# Route through static EU IP

# HTTPS_PROXY=https://user:pass@eu-01.outboundgateway.com:8443

resp = requests.post(

  "https://api.deepl.com/v2/translate",

  data={"text": "Hello",

        "target_lang": "DE"},

  headers={"Authorization": "DeepL-Auth-Key KEY"}

)

The Problem

Localization pipelines need stable outbound IPs — but your infrastructure IPs keep changing

API Key IP Restrictions

Enterprise customers restrict DeepL API keys to approved IP addresses. Your containers, serverless, and cloud services rotate IPs constantly — breaking translation access on every deploy.

Dynamic IPs Break Translation

Kubernetes pods, Lambda functions, and Docker containers get new IPs on every scale event. Your localization pipelines and real-time translation features fail silently when the whitelisted IP is no longer valid.

GDPR Compliance Audits

Translating user-generated content triggers GDPR processing obligations. Compliance audits require stable, documented outbound IPs for data flow traceability.

Multi-Environment Complexity

Dev, staging, and production environments each need separate IP management. Different microservices translate via DeepL from different IPs — unmanageable and unauditable at scale.

When Your Security Team Asks

"All DeepL API access must be restricted to approved IP addresses for GDPR compliance."

You need one stable IP to give them — not an IP that changes with every deployment.

The Solution

Route DeepL API Calls Through a Dedicated HTTPS Proxy with Static IP

Your Application

HTTPS Proxy

(Static EU IP)

DeepL API

DeepL sees your fixed EU IP addresses — every API call from translation and text rewriting to glossary management. Two IPs for high availability.

Works with all DeepL APIs — translation, text rewriting/improvement, glossaries, document translation, and usage monitoring
Set HTTPS_PROXY as an environment variable — zero code changes required
TLS passthrough — source text, translations, and API keys stay encrypted end-to-end

Why Teams Choose This for DeepL

Two static IPs for HA — whitelist both for IP-restricted DeepL keys with automatic failover, no single point of failure
EU-sovereignty alignment — DeepL is German (Cologne), and so is our proxy infrastructure. End-to-end EU-only data routing.
GDPR compliance — stable outbound IP with documented data flow for translating user-generated content
Works with both DeepL API tiers — Free (api-free.deepl.com) and Pro (api.deepl.com) — one IP covers every endpoint
Works with requests, the DeepL SDK, and any HTTP library — standard HTTPS_PROXY support
Consolidates API calls from all services — Lambda, Docker, Kubernetes, on-premise — into two auditable IPs

Designed For

Localization Teams

Running automated translation pipelines with DeepL that need stable IPs for batch processing and IP-restricted API access

SaaS Builders

Embedding real-time translation features in EU SaaS products that need IP-whitelisted DeepL access across environments

Enterprise IT Teams

Scaling document translation and content workflows across multi-region deployments that require consistent, auditable outbound IPs

Compliance Officers

Ensuring GDPR compliance when translating user-generated content, with auditable outbound IP trails and EU-only routing

Implementation

Set HTTPS_PROXY as an environment variable. All DeepL API calls route through your static EU IP. No code changes needed.

Python (requests)

Set HTTPS_PROXY in your environment. The requests library picks it up automatically.

# .env or shell
HTTPS_PROXY=https://user:pass@eu-01.outboundgateway.com:8443
DEEPL_API_KEY=your_auth_key

import os
import requests

# requests reads HTTPS_PROXY from the environment automatically
resp = requests.post(
    "https://api.deepl.com/v2/translate",
    data={
        "text": "Hello, world!",
        "target_lang": "DE",
    },
    headers={
        "Authorization": f"DeepL-Auth-Key {os.environ['DEEPL_API_KEY']}",
    },
)

print(resp.json()["translations"][0]["text"])

Node.js (fetch)

Same pattern — set HTTPS_PROXY in your environment. Use https-proxy-agent for explicit control.

// .env or shell
HTTPS_PROXY=https://user:pass@eu-01.outboundgateway.com:8443
DEEPL_API_KEY=your_auth_key

const { HttpsProxyAgent } = require('https-proxy-agent');

const agent = new HttpsProxyAgent(process.env.HTTPS_PROXY);

// Every request routes through your static EU IP
const body = new URLSearchParams({
  text: 'Hello, world!',
  target_lang: 'DE',
});

const res = await fetch('https://api.deepl.com/v2/translate', {
  method: 'POST',
  headers: {
    'Authorization': `DeepL-Auth-Key ${process.env.DEEPL_API_KEY}`,
  },
  body,
  agent,
});

console.log(await res.json());

Docker / Kubernetes / Lambda

Set the env var in your platform config. Every environment works the same way.

# Docker Compose: reference a .env file (never hardcode secrets)
services:
  app:
    env_file:
      - .env

# Kubernetes: use a Secret object
env:
  - name: HTTPS_PROXY
    valueFrom:
      secretKeyRef:
        name: outboundgateway-proxy
        key: proxy-url

# AWS Lambda: set in function environment variables
HTTPS_PROXY=${OUTBOUNDGATEWAY_PROXY_URL}

Two Static IPs for High Availability

You get two static IP addresses (e.g. 51.xx.xx.10 and 51.xx.xx.11). Whitelist both for your IP-restricted DeepL keys — if one proxy node goes down, traffic automatically fails over. No single point of failure for your translation workflows.

📖 Complete Documentation: For detailed examples, error handling, and advanced configurations, see our Python SSL Proxy Guide, Node.js Guide, and all other language guides.

Built for EU Translation

EU-hosted infrastructure designed for GDPR compliance for your DeepL translation workflows.

EU-to-EU Infrastructure

DeepL is based in Cologne, Germany — and so is our proxy infrastructure. Your translation traffic stays entirely within the EU. Zero cross-border hops.

GDPR-Conscious

TLS passthrough means we never see your source text or translations. API keys and content stay encrypted end-to-end through the proxy.

No US-Based Routing

API traffic routes entirely within EU infrastructure. No detours through US servers that could complicate GDPR compliance for translated content.

Clear Audit Trail

Two static IPs provide a clear, auditable outbound identity for GDPR reviews. Automatic failover keeps your translation workflows running during maintenance.

Why Developers Choose OutboundGateway for DeepL

Two Static IPs for HA

Two fixed IPs for all DeepL API calls. Whitelist both for IP-restricted keys — automatic failover if one node goes down.

Zero Code Changes

Set the HTTPS_PROXY env var. requests, fetch, axios, and the DeepL SDK detect it automatically. Your translation code works as-is.

EU-Hosted Infrastructure

European data centers. GDPR-conscious setup. DeepL is German — your traffic stays in the EU, end to end.

All DeepL APIs

Translation, text rewriting, glossaries, documents — and both Free and Pro tiers. One static IP covers every endpoint your app uses.

End-to-End Encryption

TLS passthrough means we can't see your traffic. Source text, translations, and API keys stay completely private.

Simple Transparent Pricing

€29/month flat. No usage tiers, no per-request billing, no surprises. Cancel anytime.

Get Your Static EU IP for DeepL

Stop worrying about dynamic IPs breaking your DeepL API access. Start using a dedicated, EU-based static IP for GDPR-compliant translation workflows.

€29/month starter plan • 7-day refund policy • Direct founder support

Still Deciding?

We're happy to help you determine if OutboundGateway is the right fit for your DeepL translation integrations.

Contact Our Founders →