🇪🇺 Static IP for Aleph Alpha — Sovereign AI Proxy

🇪🇺 Static IP for Aleph Alpha

Calling Aleph Alpha Luminous or Pharia APIs from containers, serverless, or cloud platforms? Your dynamic outbound IP changes on every deploy. Route LLM completions, embeddings, and multimodal requests through a dedicated static EU IP for GDPR and EU AI Act compliant AI integrations.

Get Your EU Static IP See How It Works

completion.py

import requests

# Route through static EU IP

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

resp = requests.post(

"https://api.aleph-alpha.com/complete",

headers={"Authorization": "Bearer KEY"},

json={"model": "luminous-supreme",

"prompt": "Summarize this"}

)

The Problem

EU AI deployments require stable, auditable outbound IPs — but your infrastructure IPs keep changing

API Key IP Restrictions

Enterprise AI deployments restrict API keys to approved IP addresses. Your containers, serverless, and cloud services rotate IPs constantly — breaking Aleph Alpha access on every deploy.

Dynamic IPs Break AI Pipelines

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

GDPR & EU AI Act Compliance

Aleph Alpha is chosen for EU data sovereignty. Compliance audits under GDPR and the EU AI Act demand stable, documented outbound IPs with full data flow traceability.

Multi-Environment Complexity

Dev, staging, and production environments each need separate IP management. Different microservices call Aleph Alpha from different IPs — unmanageable and unauditable at scale.

When Your DPO Asks

"All AI API access must use approved EU IP addresses with full traceability for GDPR and EU AI Act compliance."

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

The Solution

Route Aleph Alpha API Calls Through a Dedicated HTTPS Proxy with Static IP

Your AI Application

HTTPS Proxy

(Static EU IP)

Aleph Alpha API

Aleph Alpha sees your fixed EU IP addresses — every API call from Luminous completions to Pharia inference. Two IPs for high availability.

Works with all Aleph Alpha APIs — Luminous completions, embeddings, multimodal (text+image), and Pharia models

Set HTTPS_PROXY as an environment variable — zero code changes required

TLS passthrough — prompts, embeddings, and API keys stay encrypted end-to-end

Why Teams Choose This for Aleph Alpha

Two static IPs for HA — whitelist both for IP-restricted API keys with automatic failover, no single point of failure

EU-sovereignty alignment — Aleph Alpha is German (Heidelberg), and so is our proxy infrastructure. End-to-end EU-only data routing.

GDPR + EU AI Act compliance — stable outbound IP with documented data flow for AI system audits

Works with both model families — Luminous (multimodal) and Pharia (sovereign EU) — one IP covers every endpoint

Works with requests, the Aleph Alpha SDK, LangChain, 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

AI Developers

Building AI applications with Aleph Alpha's Luminous or Pharia models that need a stable outbound IP for enterprise security

EU Public Sector

Government and public institutions using Aleph Alpha for sovereign AI that requires auditable, EU-only outbound infrastructure

Enterprise AI Teams

Running production AI workloads with Aleph Alpha that require IP-restricted API access and stable infrastructure across environments

Compliance Officers

Ensuring GDPR and EU AI Act compliance for AI integrations with auditable outbound IP trails and EU-only data routing

Implementation

Set HTTPS_PROXY as an environment variable. All Aleph Alpha 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
ALEPH_ALPHA_API_KEY=your_api_key

import os
import requests

# requests reads HTTPS_PROXY from the environment automatically
resp = requests.post(
    "https://api.aleph-alpha.com/complete",
    headers={"Authorization": f"Bearer {os.environ['ALEPH_ALPHA_API_KEY']}"},
    json={
        "model": "luminous-supreme",
        "prompt": "Summarize the following document:",
        "maximum_tokens": 256,
    },
)

print(resp.json()["completions"][0]["completion"])

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
ALEPH_ALPHA_API_KEY=your_api_key

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

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

// Every request routes through your static EU IP
const res = await fetch('https://api.aleph-alpha.com/complete', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ALEPH_ALPHA_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'luminous-supreme',
    prompt: 'Summarize the following document:',
  }),
  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 API keys — if one proxy node goes down, traffic automatically fails over. No single point of failure for your AI workloads.

📖 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 European AI

EU-hosted infrastructure designed for GDPR and EU AI Act compliance for your Aleph Alpha integrations.

EU-to-EU Infrastructure

Aleph Alpha is based in Heidelberg, Germany — and so is our proxy infrastructure. Your AI API traffic stays entirely within the EU. Zero cross-border hops.

GDPR + EU AI Act Aligned

TLS passthrough means we never see your prompts or outputs. Stable outbound IPs provide documented data flow for AI system compliance under GDPR and the EU AI Act.

No US-Based Routing

API traffic routes entirely within EU infrastructure. No detours through US servers that would compromise Aleph Alpha's data sovereignty promise.

Clear Audit Trail

Two static IPs provide a clear, auditable outbound identity for AI compliance reviews. Automatic failover keeps your AI workloads running during maintenance.

Why Developers Choose OutboundGateway for Aleph Alpha

Two Static IPs for HA

Two fixed IPs for all Aleph Alpha 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, the Aleph Alpha SDK, and LangChain detect it automatically. Your AI code works as-is.

EU-Hosted Infrastructure

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

Luminous + Pharia

Both model families — Luminous (multimodal) and Pharia (sovereign EU) — one static IP covers every Aleph Alpha endpoint your app uses.

End-to-End Encryption

TLS passthrough means we can't see your traffic. Prompts, embeddings, model outputs, and API keys stay completely private.

Simple Transparent Pricing

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