🇪🇺 Static IP for Regolo AI — EU LLM API Proxy

🇪🇺 Static IP for Regolo AI

Calling Regolo AI APIs from containers, serverless functions, or cloud platforms? Your dynamic outbound IP changes on every deploy. Route LLM completions, embeddings, RAG pipelines, and all Regolo API calls through a dedicated static EU IP for GDPR-compliant whitelisting.

Get Your EU Static IP See How It Works

chat.py

from openai import OpenAI

# Route through static EU IP

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

client = OpenAI(

base_url="https://api.regolo.ai/v1",

api_key="YOUR_REGOLO_KEY"

)

resp = client.chat.completions.create(

model="gemma-4-31b",

messages=[{"role": "user",

"content": "Summarize this document"}]

)

The Problem

Enterprise AI platforms and internal tools require IP whitelisting for LLM API access — but your infrastructure IPs keep changing

Enterprise API Security Requirements

Organizations using Regolo AI for RAG pipelines, chatbots, and document processing need IP whitelisting to secure their API keys and model access.

Dynamic IPs in Cloud Infrastructure

Containers, serverless functions, and Kubernetes pods change IPs constantly. Your whitelisted IP becomes invalid on every deploy or scale event.

GDPR Compliance Audits

Regolo AI's zero data retention promise needs matching infrastructure. Compliance audits require stable, auditable outbound IPs for data flow documentation.

Multi-Environment Complexity

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

When Your Security Team Asks

"All LLM 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 Regolo AI API Calls Through a Dedicated HTTPS Proxy with Static IP

Your AI Application

HTTPS Proxy

(Static EU IP)

Regolo AI API

Regolo AI sees one fixed EU IP address — every API call from chat completions to embeddings to custom model inference.

Works with all Regolo APIs — chat completions, embeddings, audio transcription, custom model endpoints

Set HTTPS_PROXY as an environment variable — zero code changes required

TLS passthrough — API keys and model inputs stay encrypted end-to-end

Why Teams Choose This for Regolo AI

One static IP to whitelist — works across all Regolo endpoints (chat, embeddings, audio, custom models)

OpenAI SDK compatible — just swap the base URL and set the proxy env var, no new SDKs to learn

EU-to-EU routing — Regolo hosts in European data centers, and so do we. Zero cross-border latency.

GDPR audit trail — stable outbound IP for data flow documentation and compliance reviews

Works with Regolo core models and custom hosted models — Llama, Qwen, Mistral, Gemma, MiniMax, and your own deployments

Consolidates API calls from all services — RAG pipelines, Lambda, Docker, Kubernetes, LangChain, LlamaIndex — into one IP

Designed For

AI Developers

Building AI-powered applications with Regolo's LLM APIs that need a stable outbound IP for enterprise security and IP whitelisting

EU SaaS Builders

Running European SaaS platforms with Regolo-powered features that need IP-whitelisted API access for GDPR-conscious clients

Data Engineering Teams

Building RAG pipelines and document processing workflows with Regolo embeddings and chat models that require stable IPs

Compliance Officers

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

Implementation

Set the proxy URL as an environment variable. All Regolo AI API calls route through your static IP. No code changes needed.

Python (OpenAI SDK)

Regolo AI is fully OpenAI-compatible. Use the official openai Python package — just change the base_url.

# Set environment variable (recommended)
# export HTTPS_PROXY=https://user:pass@eu-01.outboundgateway.com:8443

from openai import OpenAI

# Point OpenAI SDK at Regolo's endpoint
client = OpenAI(
    base_url="https://api.regolo.ai/v1",
    api_key="YOUR_REGOLO_API_KEY"
)

# SDK auto-detects HTTPS_PROXY env var
response = client.chat.completions.create(
    model="gemma-4-31b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain RAG in one paragraph."}
    ]
)

print(response.choices[0].message.content)

Node.js (OpenAI SDK)

Same OpenAI SDK works in Node.js. Swap the base URL and the proxy handles the rest.

// Set in your environment or .env
HTTPS_PROXY=https://user:pass@eu-01.outboundgateway.com:8443

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.regolo.ai/v1',
  apiKey: process.env.REGOLO_API_KEY
});

const response = await client.chat.completions.create({
  model: 'qwen3.5-122b-a10b',
  messages: [
    { role: 'user', content: 'Summarize this document...' }
  ]
});

console.log(response.choices[0].message.content);

LangChain Integration

LangChain works seamlessly with Regolo via the OpenAI-compatible interface.

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

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="mistral-small-4-119b-2603",
    openai_api_key="YOUR_REGOLO_API_KEY",
    openai_api_base="https://api.regolo.ai/v1"
)

response = llm.invoke("What are the benefits of RAG?")
print(response.content)

Environment Variable Setup

Works everywhere — Docker, Lambda, Kubernetes, CI/CD. Set it once, all Regolo AI API calls use your static IP.

# Set in your environment, .env, or platform config
HTTPS_PROXY=https://user:pass@eu-01.outboundgateway.com:8443
HTTP_PROXY=https://user:pass@eu-01.outboundgateway.com:8443

# Most HTTP clients (requests, fetch, axios, openai SDK)
# automatically detect and use HTTPS_PROXY.
# No code changes needed.

📖 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 with GDPR-conscious data handling for your Regolo AI integrations.

EU-to-EU Infrastructure

Regolo hosts in European data centers, and so does our proxy. Your LLM API traffic stays entirely within the EU — zero cross-border hops.

GDPR + Zero Data Retention

Regolo's zero data retention policy pairs perfectly with our TLS passthrough. We can't see your data, and neither Regolo nor our proxy stores it.

No US-Based Routing

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

100% Green Energy Alignment

Regolo runs on carbon-free energy, and our EU infrastructure shares the same commitment. End-to-end green AI infrastructure.

Why Developers Choose OutboundGateway for Regolo AI

Dedicated Static IP

One fixed IP for all Regolo AI API calls. Whitelist it once in your account settings. Works across all Regolo models and endpoints.

Zero Code Changes

Set the HTTPS_PROXY env var. The OpenAI SDK, LangChain, and LlamaIndex automatically detect it. Your Regolo integrations work as-is.

EU-Hosted Infrastructure

European data centers. GDPR-conscious setup. Perfect for businesses with EU compliance requirements and Regolo's zero data retention promise.

All Regolo Models

Core models and custom deployments — Llama, Qwen, Mistral, Gemma, MiniMax, Whisper, and your own Hugging Face models. One static IP covers everything.

End-to-End Encryption

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

Simple Transparent Pricing

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