🇪🇺 Fixed egress for open banking

🇪🇺 Static IP for BridgeAPI

Your BridgeAPI banking sync and payment initiation calls keep failing because your cloud platform rotates IPs and breaks the firewall whitelist. Route all open banking calls through two fixed EU IPs that never change.

Get Your EU Static IP See How It Works

payment_init.py

# .env

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

import requests

r = requests.post(

"https://api.bridgeapi.io/v2/payment-requests",

headers={"Client-Id": "..",

"Client-Secret": ".."})

The Problem

BridgeAPI connects your app to real bank accounts under strict PSD2 and payment institution regulations. Those bank APIs and firewalls enforce IP whitelisting, and your cloud platform's rotating IPs keep breaking it.

Bank APIs enforce IP whitelisting

BridgeAPI connects to banks that operate under PSD2 and strict security frameworks. Those banks require BridgeAPI's outbound calls to come from known, whitelisted IPs. When your app's cloud platform rotates the outbound IP, the bank rejects the connection.

Payment initiation fails silently

When a customer initiates an account-to-account payment through your app, and the BridgeAPI call gets blocked by an IP mismatch, the payment fails. The customer sees an error, the conversion drops, and the revenue is lost.

PSD2 and payment institution audits

BridgeAPI is a licensed payment institution. Your integration with it falls under PSD2 and national payment regulations. Auditors need a documented, stable outbound IP for every banking sync and payment initiation call. Dynamic IPs make compliance reporting impossible.

Account verification drops during onboarding

When a new customer verifies their bank account during onboarding or checkout, the BridgeAPI call needs to succeed on the first try. If the IP is blocked mid-flow, the customer abandons and you lose the sign-up.

The Solution

Route all BridgeAPI calls through a fixed EU IP pair

Every call your app makes to BridgeAPI for banking sync, payment initiation, or account verification leaves from the same pair of EU addresses. Whitelist both once, and every future banking call passes the firewall.

One env var covers all BridgeAPI endpoints. Set HTTPS_PROXY and your existing requests or fetch calls route through the proxy.

Two fixed EU IPs with automatic failover. BridgeAPI is Paris-based, and so is OutboundGateway. Traffic stays EU-to-EU.

TLS passthrough. The proxy never sees your banking credentials, customer data, or payment details.

Implementation

Set HTTPS_PROXY and your existing code works as-is.

Python (payment initiation)

Your existing code works as-is. requests reads HTTPS_PROXY automatically.

# .env
HTTPS_PROXY=https://user:pass@eu-01.outboundgateway.com:8443
BRIDGE_CLIENT_ID=your_client_id
BRIDGE_CLIENT_SECRET=your_secret

import os
import requests

# requests honours HTTPS_PROXY automatically
r = requests.post(
    "https://api.bridgeapi.io/v2/payment-requests",
    headers={
        "Client-Id": os.environ["BRIDGE_CLIENT_ID"],
        "Client-Secret": os.environ["BRIDGE_CLIENT_SECRET"],
        "Content-Type": "application/json",
    },
    json={"amount": {"value": "100.00", "currency": "EUR"}},
)

print(r.json())

Node.js (banking sync)

In Node, pass the proxy explicitly with https-proxy-agent.

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

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

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

// Every BridgeAPI call routes through your fixed EU IP
const res = await fetch('https://api.bridgeapi.io/v2/items', {
  headers: {
    'Client-Id': process.env.BRIDGE_CLIENT_ID,
    'Client-Secret': process.env.BRIDGE_CLIENT_SECRET,
  },
  agent,
});

Docker / Kubernetes / env

Set it wherever your app runs.

# Docker Compose
services:
  app:
    env_file: .env

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

Two IPs, EU-to-EU

Your account comes with two static IP addresses. BridgeAPI is Paris-based and OutboundGateway is EU-based, so your banking traffic stays entirely within EU jurisdiction. If one proxy node is briefly unavailable, traffic shifts to the other.

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

Why open banking teams choose OutboundGateway

A pair of fixed IPs

Two addresses to whitelist on bank firewalls, with automatic failover. No rotating cloud pool.

Zero code changes

Set one env var and your existing requests or fetch calls to BridgeAPI work as-is.

Paris to EU

BridgeAPI is Paris-based and OutboundGateway is EU-based. Banking traffic stays EU-to-EU.

All BridgeAPI services

Banking sync, payment initiation, account verification. One pair covers every endpoint.

Encrypted end to end

TLS passthrough means the proxy can't read your traffic. Banking credentials stay private.

Flexible plans

Starting from €19/month. Flexible plans for every scale. Cancel anytime.

Frequently asked questions

Does BridgeAPI enforce IP whitelisting?

BridgeAPI connects to banks that operate under PSD2 and strict security frameworks. Those banks, and BridgeAPI itself, may require your outbound calls to come from whitelisted IPs. When your cloud platform rotates the IP, those calls get blocked. OutboundGateway gives you two fixed EU IPs that never change, so the whitelist always passes.

Does this work for all BridgeAPI services?

Yes. The proxy isn't endpoint-specific. Whether your app calls banking sync, payment initiation, or account verification on api.bridgeapi.io, all of it routes through the same fixed pair of EU IPs. Set HTTPS_PROXY once and every BridgeAPI call is covered.

Does this help with PSD2 compliance?

Yes. PSD2 requires strong customer authentication and traceable access for payment services. A documented, stable EU outbound IP gives your compliance team a clear answer when auditors ask where banking calls originate from. OutboundGateway routes through EU data centres owned by an EU company, so the full path stays within EU jurisdiction.