BaseChatOpenAI

Model name to use.

What sampling temperature to use.

Holds any model parameters valid for create call not explicitly specified.

API key to use.

Can be inferred from the OPENAI_API_KEY environment variable, or specified as a string, or sync or async callable that returns a string.

export OPENAI_API_KEY=...

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-5-nano")

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-5-nano", api_key="...")

from langchain_openai import ChatOpenAI

def get_api_key() -> str:
    # Custom logic to retrieve API key
    return "..."

model = ChatOpenAI(model="gpt-5-nano", api_key=get_api_key)

from langchain_openai import ChatOpenAI

async def get_api_key() -> str:
    # Custom async logic to retrieve API key
    return "..."

model = ChatOpenAI(model="gpt-5-nano", api_key=get_api_key)

Base URL path for API requests, leave blank if not using a proxy or service emulator.

Automatically inferred from env var OPENAI_ORG_ID if not provided.

Timeout for requests to OpenAI completion API. Can be float, httpx.Timeout or None.

Whether to include usage metadata in streaming output. If enabled, an additional message chunk will be generated during the stream including usage metadata.

This parameter is enabled unless openai_api_base is set or the model is initialized with a custom client, as many chat completions APIs do not support streaming token usage.

Maximum number of retries to make when generating.

Penalizes repeated tokens.

Penalizes repeated tokens according to frequency.

Seed for generation

Whether to return logprobs.

Number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used.

Modify the likelihood of specified tokens appearing in the completion.

Whether to stream the results or not.

Number of chat completions to generate for each prompt.

Total probability mass of tokens to consider at each step.

Maximum number of tokens to generate.

Constrains effort on reasoning for reasoning models. For use with the Chat Completions API.

Reasoning models only.

Currently supported values are 'minimal', 'low', 'medium', and 'high'. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.

Reasoning parameters for reasoning models. For use with the Responses API.

reasoning={
    "effort": "medium",  # Can be "low", "medium", or "high"
    "summary": "auto",  # Can be "auto", "concise", or "detailed"
}

Controls the verbosity level of responses for reasoning models. For use with the Responses API.

Currently supported values are 'low', 'medium', and 'high'.

The model name to pass to tiktoken when using this class.

Tiktoken is used to count the number of tokens in documents to constrain them to be under a certain limit.

By default, when set to None, this will be the same as the embedding model name. However, there are some cases where you may want to use this Embedding class with a model name not supported by tiktoken. This can include when using Azure embeddings or when using one of the many model providers that expose an OpenAI-like API but with different models. In those cases, in order to avoid erroring when tiktoken is called, you can specify a model name to use here.

Optional httpx.Client.

Only used for sync invocations. Must specify http_async_client as well if you'd like a custom client for async invocations.

Optional httpx.AsyncClient.

Only used for async invocations. Must specify http_client as well if you'd like a custom client for sync invocations.

Default stop sequences.

Optional additional JSON properties to include in the request parameters when making requests to OpenAI compatible APIs, such as vLLM, LM Studio, or other providers.

This is the recommended way to pass custom parameters that are specific to your OpenAI-compatible API provider but not part of the standard OpenAI API.

Whether to include response headers in the output message response_metadata.

Parameters of the OpenAI client or chat.completions endpoint that should be disabled for the given model.

Should be specified as {"param": None | ['val1', 'val2']} where the key is the parameter and the value is either None, meaning that parameter should never be used, or it's a list of disabled values for the parameter.

For example, older models may not support the 'parallel_tool_calls' parameter at all, in which case disabled_params={"parallel_tool_calls": None} can be passed in.

If a parameter is disabled then it will not be used by default in any methods, e.g. in with_structured_output. However this does not prevent a user from directly passed in the parameter during invocation.

Additional fields to include in generations from Responses API.

Supported values:

• 'file_search_call.results'
• 'message.input_image.image_url'
• 'computer_call_output.output.image_url'
• 'reasoning.encrypted_content'
• 'code_interpreter_call.outputs'

Latency tier for request.

Options are 'auto', 'default', or 'flex'.

Relevant for users of OpenAI's scale tier service.

If True, OpenAI may store response data for future use.

Defaults to True for the Responses API and False for the Chat Completions API.

Truncation strategy (Responses API).

Can be 'auto' or 'disabled' (default).

If 'auto', model may drop input items from the middle of the message sequence to fit the context window.

If True, always pass previous_response_id using the ID of the most recent response. Responses API only.

Input messages up to the most recent response will be dropped from request payloads.

For example, the following two are equivalent:

model = ChatOpenAI(
    model="...",
    use_previous_response_id=True,
)
model.invoke(
    [
        HumanMessage("Hello"),
        AIMessage("Hi there!", response_metadata={"id": "resp_123"}),
        HumanMessage("How are you?"),
    ]
)

model = ChatOpenAI(model="...", use_responses_api=True)
model.invoke([HumanMessage("How are you?")], previous_response_id="resp_123")

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

If not specified then will be inferred based on invocation params.

Version of AIMessage output format to use.

This field is used to roll-out new output formats for chat model AIMessage responses in a backwards-compatible way.

Supported values:

• 'v0': AIMessage format as of langchain-openai 0.3.x.
• 'responses/v1': Formats Responses API output items into AIMessage content blocks (Responses API only)
• 'v1': v1 of LangChain cross-provider standard.

Same as model_name.

Build extra kwargs from additional params that were passed in.

Validate temperature parameter for different models.

• gpt-5 models (excluding gpt-5-chat) only allow temperature=1 or unset (Defaults to 1)

Validate that api key and python package exists in environment.

Get the tokens present in the text with tiktoken package.

Bind tool-like objects to this chat model.

Assumes model is compatible with OpenAI tool-calling API.

Model wrapper that returns outputs formatted to match the given schema.