ChatAzureOpenAI

Azure OpenAI LLM provider for Browser Use with enterprise features

Overview

ChatAzureOpenAI provides integration with Azure OpenAI Service, supporting GPT-4, GPT-5, and other OpenAI models through Microsoft Azure’s enterprise-grade infrastructure. It includes support for both Chat Completions API and the newer Responses API.

Basic Usage

from browser_use import Agent, ChatAzureOpenAI
import asyncio

async def main():
    llm = ChatAzureOpenAI(
        model='gpt-4o',
        api_key='your_azure_api_key',
        azure_endpoint='https://your-resource.openai.azure.com',
        azure_deployment='your-deployment-name',
    )
    agent = Agent(
        task="Find the number 1 post on Show HN",
        llm=llm,
    )
    await agent.run()

if __name__ == "__main__":
    asyncio.run(main())

Configuration

Required Parameters

model · str · required

Azure OpenAI model deployment name. Common options:

• gpt-4o: Latest GPT-4 optimized model
• gpt-4-turbo: High performance GPT-4
• gpt-4.1-mini: Fast and cost-effective
• gpt-5, gpt-5-mini, gpt-5-nano: Next generation models
• gpt-5.1-codex-mini, gpt-5.1-codex-max: Codex models (require Responses API)

Azure-Specific Parameters

api_key · str · default: "None"

Azure OpenAI API key. Falls back to AZURE_OPENAI_KEY or AZURE_OPENAI_API_KEY environment variable.

Get your API key from Azure Portal

azure_endpoint · str · default: "None"

Your Azure OpenAI resource endpoint. Falls back to AZURE_OPENAI_ENDPOINT environment variable.

Example: https://your-resource.openai.azure.com

azure_deployment · str · default: "None"

Your Azure OpenAI deployment name. Falls back to AZURE_OPENAI_DEPLOYMENT environment variable.

api_version · str · default: "2024-12-01-preview"

Azure OpenAI API version. Use 2025-03-01-preview or later for Responses API support.

azure_ad_token · str · default: "None"

Azure Active Directory token for authentication (alternative to API key).

azure_ad_token_provider · Any · default: "None"

Token provider function for dynamic Azure AD authentication.

base_url · str · default: "None"

Custom base URL (alternative to azure_endpoint).

Model Parameters

temperature · float · default: "0.2"

Sampling temperature (0.0 to 2.0). Lower values make output more deterministic.

frequency_penalty · float · default: "0.3"

Penalty for token frequency (-2.0 to 2.0).

reasoning_effort · str · default: "low"

Reasoning effort for reasoning models. Options: low, medium, high.

seed · int · default: "None"

Random seed for deterministic output.

service_tier · str · default: "None"

Service tier: auto, default, flex, priority, or scale.

top_p · float · default: "None"

Nucleus sampling parameter (0.0 to 1.0).

max_completion_tokens · int · default: "4096"

Maximum tokens in the completion.

Client Parameters

organization · str · default: "None"

Azure OpenAI organization ID.

timeout · float · default: "None"

Request timeout in seconds.

max_retries · int · default: "5"

Maximum number of retries for failed requests.

default_headers · dict · default: "None"

Additional headers to include in all requests.

default_query · dict · default: "None"

Additional query parameters for all requests.

http_client · httpx.AsyncClient · default: "None"

Custom async HTTP client.

Responses API Parameters

use_responses_api · bool | str · default: "auto"

Whether to use the Responses API instead of Chat Completions API.

• True: Always use Responses API
• False: Always use Chat Completions API
• "auto": Automatically detect based on model (default)

Responses API is required for models like gpt-5.1-codex-mini and computer-use-preview.

Advanced Parameters

add_schema_to_system_prompt · bool · default: "False"

Add JSON schema to system prompt for better structured output.

dont_force_structured_output · bool · default: "False"

Disable forced structured output even when output_format is provided.

remove_min_items_from_schema · bool · default: "False"

Remove minItems from JSON schema for provider compatibility.

remove_defaults_from_schema · bool · default: "False"

Remove default values from JSON schema.

Advanced Usage

With Azure AD Authentication

from browser_use import Agent, ChatAzureOpenAI
from azure.identity.aio import DefaultAzureCredential

# Using Azure AD token provider
async def get_azure_ad_token():
    credential = DefaultAzureCredential()
    token = await credential.get_token("https://cognitiveservices.azure.com/.default")
    return token.token

llm = ChatAzureOpenAI(
    model='gpt-4o',
    azure_endpoint='https://your-resource.openai.azure.com',
    azure_deployment='your-deployment',
    azure_ad_token_provider=get_azure_ad_token,
)

agent = Agent(task="Your task", llm=llm)

Using Responses API

from browser_use import Agent, ChatAzureOpenAI

# Explicitly use Responses API for codex models
llm = ChatAzureOpenAI(
    model='gpt-5.1-codex-mini',
    api_key='your_azure_api_key',
    azure_endpoint='https://your-resource.openai.azure.com',
    azure_deployment='codex-deployment',
    api_version='2025-03-01-preview',  # Required for Responses API
    use_responses_api=True,
)

agent = Agent(task="Code generation task", llm=llm)

The Responses API is automatically used for models: gpt-5.1-codex-mini, gpt-5.1-codex-max, gpt-5-codex, and computer-use-preview.

Structured Output

from browser_use import Agent, ChatAzureOpenAI
from pydantic import BaseModel

class CodeAnalysis(BaseModel):
    language: str
    complexity: str
    suggestions: list[str]

llm = ChatAzureOpenAI(
    model='gpt-4o',
    api_key='your_azure_api_key',
    azure_endpoint='https://your-resource.openai.azure.com',
    azure_deployment='your-deployment',
)

agent = Agent(
    task="Analyze code",
    llm=llm,
    output_model_schema=CodeAnalysis,
)

result = await agent.run()
print(result.structured_output)  # CodeAnalysis instance

With Custom Headers

from browser_use import Agent, ChatAzureOpenAI

llm = ChatAzureOpenAI(
    model='gpt-4o',
    api_key='your_azure_api_key',
    azure_endpoint='https://your-resource.openai.azure.com',
    azure_deployment='your-deployment',
    default_headers={'X-Custom-Header': 'value'},
)

agent = Agent(task="Your task", llm=llm)

Environment Setup

.env

AZURE_OPENAI_KEY=your_api_key_here
# or
AZURE_OPENAI_API_KEY=your_api_key_here

AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com
AZURE_OPENAI_DEPLOYMENT=your-deployment-name

Error Handling

from browser_use import Agent, ChatAzureOpenAI
from browser_use.llm.exceptions import (
    ModelProviderError,
    ModelRateLimitError
)

try:
    llm = ChatAzureOpenAI(
        model='gpt-4o',
        api_key='your_azure_api_key',
        azure_endpoint='https://your-resource.openai.azure.com',
        azure_deployment='your-deployment',
    )
    agent = Agent(task="Your task", llm=llm)
    result = await agent.run()
except ModelRateLimitError as e:
    print(f"Rate limit exceeded: {e.message}")
except ModelProviderError as e:
    print(f"Azure API error: {e.message}")
    print(f"Status code: {e.status_code}")

Properties

provider

Returns the provider name: "azure"

llm = ChatAzureOpenAI(
    model='gpt-4o',
    azure_endpoint='https://your-resource.openai.azure.com',
)
print(llm.provider)  # "azure"

name

Returns the model name.

llm = ChatAzureOpenAI(
    model='gpt-4o',
    azure_endpoint='https://your-resource.openai.azure.com',
)
print(llm.name)  # "gpt-4o"

Methods

get_client()

Returns an AsyncAzureOpenAI client instance.

llm = ChatAzureOpenAI(
    model='gpt-4o',
    azure_endpoint='https://your-resource.openai.azure.com',
)
client = llm.get_client()
# Use client directly for advanced operations

ainvoke()

Asynchronously invoke the model with messages. Automatically routes between Chat Completions API and Responses API based on model.

from browser_use.llm.messages import SystemMessage, UserMessage

llm = ChatAzureOpenAI(
    model='gpt-4o',
    api_key='your_azure_api_key',
    azure_endpoint='https://your-resource.openai.azure.com',
    azure_deployment='your-deployment',
)

messages = [
    SystemMessage(content="You are a helpful assistant"),
    UserMessage(content="What is Browser Use?")
]

response = await llm.ainvoke(messages)
print(response.completion)     # String response
print(response.usage)          # Token usage
print(response.stop_reason)    # Why generation stopped

Parameters

• messages (list[BaseMessage]): List of messages
• output_format (type[T] | None): Optional Pydantic model for structured output

Returns

ChatInvokeCompletion[T] | ChatInvokeCompletion[str] with:

• completion: Response content
• usage: Token usage (includes prompt_cached_tokens when available)
• stop_reason: Finish reason

API Differences

Chat Completions API vs Responses API

Feature	Chat Completions	Responses API
Models	Most GPT models	Codex, computer-use
API Version	Any	2025-03-01-preview+
Token Field Names	Standard	input_tokens/output_tokens
Response Format	choices[0].message	output_text
Auto-Detection	Default	For specific models

Azure-Specific Features

Enterprise Security

• Azure AD authentication support
• Private network access with VNet
• Managed identity integration
• Compliance certifications

Deployment Options

• Dedicated model deployments
• Custom model fine-tuning
• Multi-region availability
• Provisioned throughput units (PTU)

Monitoring and Logging

• Azure Monitor integration
• Request tracing
• Usage analytics
• Cost management

Related

• ChatBrowserUse - Recommended provider
• ChatOpenAI - Standard OpenAI
• ChatAnthropic