> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://respan.ai/docs/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://respan.ai/_mcp/server.

# Provider: Azure OpenAI

This page is for **Respan LLM Gateway** users.

Use Respan Gateway to call Azure OpenAI deployments (`gpt-5.5`, `gpt-5`, `gpt-5-mini`, `o3`, and the rest) while keeping unified observability (logs, cost, latency, reliability) in Respan.

## Quick setup

#### Get a Respan API key

[Sign up](https://platform.respan.ai) and create a key on the [API keys page](https://platform.respan.ai/platform/api/api-keys).

#### Add credits (recommended)

[Top up credits](https://platform.respan.ai/platform/api/billing) to pay through Respan. No Azure resource required, Respan handles provider auth and billing.

Prefer to route through your own Azure OpenAI deployment? See [Use your own Azure OpenAI key](#use-your-own-azure-openai-key-byok).

## Send your first request

Pick the integration that matches your stack. The base URL is `https://api.respan.ai/api` and the only key needed is your `RESPAN_API_KEY`. Use the `azure/` prefix plus your deployment name (or any Azure-compatible model ID) as the model.

#### OpenAI SDK

Point the standard OpenAI SDK at the Respan gateway. No Azure-specific client needed, Respan translates to your Azure deployment based on the model ID.

```python Python
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_RESPAN_API_KEY",
    base_url="https://api.respan.ai/api",
)

response = client.chat.completions.create(
    model="azure/gpt-5.5",
    messages=[{"role": "user", "content": "Hello, Azure OpenAI!"}],
)
print(response.choices[0].message.content)
```

```typescript TypeScript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.RESPAN_API_KEY,
  baseURL: "https://api.respan.ai/api",
});

const response = await client.chat.completions.create({
  model: "azure/gpt-5.5",
  messages: [{ role: "user", content: "Hello, Azure OpenAI!" }],
});
console.log(response.choices[0].message.content);
```

#### Vercel AI SDK

Use `@ai-sdk/openai` and point `createOpenAI` at the Respan gateway. Pass any Azure deployment with the `azure/` prefix.

```typescript TypeScript
import { createOpenAI } from "@ai-sdk/openai";
import { generateText } from "ai";

const respan = createOpenAI({
  apiKey: process.env.RESPAN_API_KEY!,
  baseURL: "https://api.respan.ai/api",
});

const result = await generateText({
  model: respan("azure/gpt-5.5"),
  prompt: "Hello, Azure OpenAI!",
});
console.log(result.text);
```

#### Respan API

Call the Respan REST API directly from any language.

```python Python
import requests

response = requests.post(
    "https://api.respan.ai/api/chat/completions",
    headers={
        "Authorization": "Bearer YOUR_RESPAN_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "azure/gpt-5.5",
        "messages": [{"role": "user", "content": "Hello, Azure OpenAI!"}],
    },
)
print(response.json()["choices"][0]["message"]["content"])
```

```typescript TypeScript
const response = await fetch("https://api.respan.ai/api/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.RESPAN_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "azure/gpt-5.5",
    messages: [{ role: "user", content: "Hello, Azure OpenAI!" }],
  }),
});

const data = await response.json();
console.log(data.choices[0].message.content);
```

## More integrations

Azure OpenAI models work with every Respan gateway integration:

* [OpenAI SDK](/docs/integrations/openai-sdk)
* [OpenAI Agents SDK](/docs/integrations/openai-agents-sdk)
* [LangChain](/docs/integrations/langchain)
* [LangGraph](/docs/integrations/langgraph)
* [LlamaIndex](/docs/integrations/llama-index)
* [Pydantic AI](/docs/integrations/pydantic-ai)
* [Respan native (OTel)](/docs/documentation/features/gateway/gateway-quickstart)

## Switch models

Change the `model` parameter to call any supported model through the same client. Use the `azure/` prefix plus your Azure deployment name (or model ID) to disambiguate when routing across providers. Browse the full list on the [Models page](https://platform.respan.ai/platform/models).

```python
client.chat.completions.create(model="azure/gpt-5.5", messages=messages)
client.chat.completions.create(model="azure/gpt-5-mini", messages=messages)
client.chat.completions.create(model="azure/o3", messages=messages)
client.chat.completions.create(model="openai/gpt-5.5", messages=messages)
client.chat.completions.create(model="anthropic/claude-sonnet-4-5-20250929", messages=messages)
```

## Use your own Azure OpenAI key (BYOK)

Credits are the default path. If you'd rather bill Azure directly, attach your own Azure OpenAI credentials.

#### Global (UI)

#### Open Providers

Go to the [Providers page](https://platform.respan.ai/platform/api/providers).

#### Add Azure OpenAI

Select **Azure OpenAI** and fill in the required credential fields:

* `api_key` (your Azure OpenAI API key)
* `api_base` (your Azure OpenAI resource endpoint, also called base URL)
* `api_version` (the Azure OpenAI API version to use)

Azure allows custom deployment names. Use the `azure/{deployment-name}` model ID format in gateway requests.

#### Load balancing (Optional)

Add multiple credential sets and use **Load balancing weight** to distribute traffic across them.

#### Per-request (Code)

Pass `customer_credentials` on each [Gateway request](/docs/apis/gateway/create-chat-completion). Useful when serving end-user keys.

```json
{
  "customer_credentials": {
    "azure_openai": {
      "api_key": "YOUR_AZURE_OPENAI_API_KEY",
      "api_base": "https://your-resource.openai.azure.com/",
      "api_version": "2024-10-21"
    }
  }
}
```

### Override credentials per model (Optional)

Use [`credential_override`](/docs/documentation/admin/llm_provider_keys#per-model-credential-override) when one model on a request should use a different Azure resource than the default.

```json
{
  "customer_credentials": {
    "azure_openai": {
      "api_key": "YOUR_AZURE_OPENAI_API_KEY",
      "api_base": "https://your-resource.openai.azure.com/",
      "api_version": "2024-10-21"
    }
  },
  "credential_override": {
    "azure/gpt-5.5": {
      "api_key": "ANOTHER_API_KEY",
      "api_base": "https://another-resource.openai.azure.com/",
      "api_version": "2024-10-21"
    }
  }
}
```

## Log without proxying (Optional)

Already calling Azure OpenAI directly? Send logs to Respan asynchronously to track cost, latency, and performance for those external calls.

```python
import requests

requests.post(
    "https://api.respan.ai/api/request-logs/create/",
    headers={
        "Authorization": "Bearer YOUR_RESPAN_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "azure/gpt-5.5",
        "prompt_messages": [{"role": "user", "content": "Hello, how are you?"}],
        "completion_message": {"role": "assistant", "content": "Hello from Azure OpenAI through Respan."},
        "cost": 0.001,
        "generation_time": 1.2,
        "customer_params": {"customer_identifier": "user_123"},
    },
)
```

See the [logging guide](/docs/documentation/features/tracing/spans) for the full setup.