OpenAI API Gateway

Overview

This gateway sits between your application and the OpenAI API. It listens on https://openai.mrdisc.ir:9999 and forwards every request to https://api.openai.com over TLS.

• Transparent pass-through. Method, path, query string, headers (including Authorization) and the request body are forwarded exactly as you send them. The upstream response is returned exactly as OpenAI produces it — status code, headers, body and SSE event stream.
• No registration. You authenticate with your own OpenAI API key. The gateway stores no keys, no accounts and no message contents.
• Location privacy. Because the outbound connection originates from the gateway server, OpenAI only ever sees the gateway's IP address. Caller-identity headers (forwarded-for, cookies, language, referer…) are removed before forwarding — see Location privacy.
• Universal compatibility. Works unchanged with the official OpenAI SDKs (Python and Node.js), LangChain, LlamaIndex, community libraries, and plain curl — anything that can call api.openai.com.
• Self-documenting. This page is served by the gateway itself at / and /docs.

Base URL

Replace OpenAI's API origin with the gateway origin. Keep everything else — the /v1 prefix, paths, query strings — exactly the same.

SDK configuration

Quick start

1 · Get an OpenAI API key

Create a key at platform.openai.com/api-keys. The gateway does not issue keys — billing, quotas and rate limits all come from your own OpenAI account.

2 · Point your client at the gateway

export OPENAI_API_KEY="sk-..."               # your OpenAI key
export OPENAI_BASE_URL="https://openai.mrdisc.ir:9999/v1"      # the only change

3 · Make a request

curl https://openai.mrdisc.ir:9999/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "model": "gpt-4o-mini",
        "messages": [
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Hello!"}
        ]
      }'

That's it. The JSON you get back is structurally identical to OpenAI's own response — same id, choices, usage, created fields, same error shapes.

Code examples

curl https://openai.mrdisc.ir:9999/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "model": "gpt-4o-mini",
        "messages": [{"role": "user", "content": "Hello!"}]
      }'

curl -N https://openai.mrdisc.ir:9999/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "model": "gpt-4o-mini",
        "stream": true,
        "messages": [{"role": "user", "content": "Write a haiku about proxies."}]
      }'

curl https://openai.mrdisc.ir:9999/v1/models \
  -H "Authorization: Bearer $OPENAI_API_KEY"

from openai import OpenAI

client = OpenAI(
    api_key="sk-...",                          # your OpenAI API key
    base_url="https://openai.mrdisc.ir:9999/v1",                 # <-- the ONLY change
)

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(resp.choices[0].message.content)

stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Count from 1 to 5."}],
    stream=True,                               # SSE relayed in real time
)
for event in stream:
    delta = event.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

emb = client.embeddings.create(
    model="text-embedding-3-small",
    input="The quick brown fox",
)
print(len(emb.data[0].embedding))

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "sk-...",                            // your OpenAI API key
  baseURL: "https://openai.mrdisc.ir:9999/v1",                   // <-- the ONLY change
});

const resp = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(resp.choices[0].message.content);

const stream = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Count from 1 to 5." }],
  stream: true,
});
for await (const event of stream) {
  const delta = event.choices[0]?.delta?.content ?? "";
  process.stdout.write(delta);
}

import requests

r = requests.post(
    "https://openai.mrdisc.ir:9999/v1/chat/completions",
    headers={"Authorization": "Bearer sk-..."},
    json={
        "model": "gpt-4o-mini",
        "messages": [{"role": "user", "content": "Hello!"}],
    },
    timeout=120,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])

import json
import requests

with requests.post(
    "https://openai.mrdisc.ir:9999/v1/chat/completions",
    headers={"Authorization": "Bearer sk-..."},
    json={"model": "gpt-4o-mini", "stream": True,
          "messages": [{"role": "user", "content": "Hi"}]},
    stream=True, timeout=300,
) as r:
    for line in r.iter_lines():
        if not line or not line.startswith(b"data: "):
            continue
        payload = line[len(b"data: "):]
        if payload == b"[DONE]":
            break
        chunk = json.loads(payload)
        delta = chunk["choices"][0]["delta"].get("content", "")
        print(delta, end="", flush=True)

Supported endpoints

Every path is forwarded verbatim — if OpenAI serves it, it works through the gateway. The commonly used families:

Streaming (SSE)

Set "stream": true in the request body, exactly as with OpenAI. The gateway relays server-sent events as they arrive — there is no buffering stage, so time-to-first-token and inter-chunk timing match the direct connection (plus one network hop).

• Each SSE event is forwarded in its own TCP flush.
• The terminal data: [DONE] marker passes through untouched.
• Chunked transfer framing is re-encoded for your client, but the event payload bytes are identical.
• If your client disconnects mid-stream, the upstream leg is cancelled immediately.

See the cURL / SDK tabs in Code examples for ready-to-run streaming snippets.

Authentication

The gateway is a pure middleman — it has no accounts and no keys of its own. You present your OpenAI key exactly as you would to OpenAI:

Authorization: Bearer sk-...4A2c          # your OpenAI API key, passed through untouched

• Optional OpenAI-Organization: org-... and OpenAI-Project: proj-... headers are forwarded as well.
• A missing or invalid key produces OpenAI's own 401 response, verbatim — the gateway never rewrites or interprets credentials.
• Keys are never logged, cached or stored anywhere on the gateway.

Passthrough fidelity

Passed through untouched

Transport-level adjustments (never alter the API payload)

Errors

From OpenAI (passed through verbatim)

All OpenAI-generated errors — invalid key, rate limits, context length, content filter, server errors — reach you byte-identical, with OpenAI's original status code and headers:

HTTP/1.1 401 Unauthorized

{
  "error": {
    "message": "Incorrect API key provided: sk-dummy. You can find your API key at https://platform.openai.com/account/api-keys.",
    "type": "invalid_request_error",
    "param": null,
    "code": "invalid_api_key"
  }
}

From the gateway (only when the gateway itself fails)

The only errors the gateway generates are connectivity faults between the gateway and OpenAI. They use the same {"error": {...}} envelope so your error handling stays uniform:

HTTP/1.1 502 Bad Gateway

{
  "error": {
    "message": "Upstream connection failed: ...",
    "type": "gateway_error",
    "param": null,
    "code": "upstream_unreachable"
  }
}

Codes you can see: upstream_unreachable (cannot reach api.openai.com) and internal_error (unexpected gateway fault). Anything else you receive came from OpenAI itself.

Location privacy

The gateway removes every header that could identify you — your network, region, browser or session — before forwarding the request. OpenAI sees a request coming from the gateway server's IP address and nothing more.

Stripped before forwarding

X-Forwarded-For        X-Real-IP              X-Forwarded-Host
X-Forwarded-Proto      X-Forwarded-Port       X-Forwarded-Server
X-Forwarded-Scheme     Forwarded              Via
True-Client-IP         Client-IP              X-Client-IP
X-Cluster-Client-IP    CF-Connecting-IP       CF-IPCountry
CF-Ray                 CF-Visitor             Fastly-Client-IP
X-Country-Code         X-Geo-Country          X-Geo-Lat / X-Geo-Lon
Accept-Language        Referer                Origin
Cookie

• Authorization and request payloads are not touched — only identity/location signals are removed.
• The gateway logs one line per request (IP, method, path, status, bytes, duration) for operations — never keys, never bodies.

Limits & notes

Health check

A local endpoint (not proxied) for uptime monitors:

curl https://openai.mrdisc.ir:9999/healthz

{"status":"ok","upstream":"api.openai.com"}

This documentation page is served at / and /docs. Every other path is proxied to OpenAI.

FAQ