Responses.create() unexpected keyword argument: new names

You moved a call from client.chat.completions.create() to client.responses.create() and kept the old arguments. The Responses API renamed most of them, moved some into nested objects and dropped a few, and the Python SDK checks names before it sends anything. So the TypeError comes from Python, and no request goes out.

From JavaScript, or through extra_body in Python, the same names do reach the API, and it answers with its own 400. I tried twelve Chat Completions arguments both ways (if your error names proxies and comes from creating the client, skip to that section):

Note what’s missing: the API’s message for max_tokens doesn’t point you to the new name, while the one for max_completion_tokens does.

The renames

response = client.responses.create(
    model="gpt-5.5",
    input=[{"role": "user", "content": "Hello"}],
    max_output_tokens=500,
)
print(response.output_text)

Two checks that move with the rename

Both came back as 400s once the names were right:

• max_output_tokens has a floor. max_output_tokens=5 returned Invalid 'max_output_tokens': integer below minimum value. Expected a value >= 16, but got 5 instead. The same max_tokens=5 on Chat Completions got past its checks.
• JSON mode still wants the word “json”. text={"format": {"type": "json_object"}} with the input "hi" returned Response input messages must contain the word 'json' in some form to use 'text.format' of type 'json_object'.

For a JSON schema, the shape changed too. The schema sits directly in format, next to a name. Without the name: Missing required parameter: 'text.format.name'. With it, the schema itself was checked as strict, and two more 400s came back:

Invalid schema for response_format 'answer': In context=(), 'additionalProperties' is required to be supplied and to be false.
Invalid schema for response_format 'answer': In context=(), 'required' is required to be supplied and to be an array including every key in properties. Missing 'a'.

text={"format": {
    "type": "json_schema",
    "name": "answer",
    "schema": {
        "type": "object",
        "properties": {"a": {"type": "string"}},
        "required": ["a"],
        "additionalProperties": False,
    },
}}

seed, n and stop have no replacement

The Responses API has no seed, no n and no stop. All three failed the same way on gpt-4.1-mini, so it isn’t a model limit.

frequency_penalty and presence_penalty depend on the model

These two aren’t in the Python SDK’s responses.create(), so Python raises the TypeError for every model. At the API, they’re a model question: gpt-5.5 rejected both with Unsupported parameter: 'frequency_penalty' is not supported with this model., while on gpt-4.1-mini the same request got past validation. temperature behaved like this too: 'temperature' is not supported with this model. on gpt-5.5.

client.responses.create(model="gpt-4.1-mini", input="Hello", extra_body={"frequency_penalty": 0.5})

Client.__init__() got an unexpected keyword argument 'proxies'

TypeError: Client.__init__() got an unexpected keyword argument 'proxies'

This one has nothing to do with responses.create(). httpx 0.28 removed the proxies argument, and anything that still passes it to httpx.Client() fails before a single request goes out. Older Pythons print the shorter __init__() got an unexpected keyword argument 'proxies'. Since 3.10, Python names the class, so you see Client.__init__().

The traceback tells you who passed proxies:

From OpenAI() or Anthropic()

A plain client = openai.OpenAI() was enough to raise it. Old SDK versions built their internal httpx.Client with proxies=, and pip happily installed the newest httpx next to them:

pip install -U "openai>=1.55.3"
pip install -U "anthropic>=0.40.0"

import httpx, openai

client = openai.OpenAI(http_client=httpx.Client())

openai.OpenAI(proxies=...) was never an argument of the client itself. It failed on every version I tried, and 3.37.0 adds Did you mean ‘provider’?, which isn’t what you want either. The proxy goes on the HTTP client, as below.

From your own httpx code

Here, the argument is yours. httpx.Client(proxies=...) and httpx.post(url, proxies=...) both raised the TypeError on 0.28.1, and both worked on 0.27.2.

client = httpx.Client(proxy="http://127.0.0.1:8080")

client = httpx.Client(mounts={
    "http://": httpx.HTTPTransport(proxy="http://127.0.0.1:8080"),
    "https://": httpx.HTTPTransport(proxy="http://127.0.0.1:8081"),
})

A proxy for the OpenAI client

Give the proxy to the HTTP client and the HTTP client to OpenAI. DefaultHttpxClient keeps the SDK’s own timeouts and connection limits:

client = openai.OpenAI(http_client=openai.DefaultHttpxClient(proxy="http://127.0.0.1:8080"))

Current SDKs use httpx2, not httpx

openai 3.37.0 and anthropic 2.1.0 don’t depend on httpx anymore. Both require httpx2 (2.16.0 here), so pip install openai in a fresh venv doesn’t install httpx at all. Two things follow:

These proxies tests ran on Windows 11 Pro, Python 3.14.5, October 23, 2026. Each combination of SDK and httpx ran in its own venv. The script built the clients, then sent requests through a local HTTP server acting as the proxy, which recorded every request that reached it. No real API calls were made. That test script is public too.

How this was tested

Windows 11 Pro, Python 3.14.5, openai 3.37.0, October 23, 2026. Each argument was passed to client.responses.create() against a local server that recorded the request body. The same JSON bodies were then sent with curl to https://api.openai.com/v1/responses with a key that has no credits: the API checks parameters before credits, so wrong parameters came back as 400s and valid requests as credit_balance_exhausted. No response text was generated. The test script is public.