Responses API vs Chat Completions Through a Gateway: What Moves, and Which Models Support It

OpenAI's own guidance has shifted to a newer API, while many gateways, SDK wrappers and tools still speak the older one. If you call through a gateway you need to know both: what changes between the two APIs, and whether your gateway lets you use the new one for your model. This post covers both with a tested conversion helper and data from AICredits' public catalog.

Disclosure: AICredits links on this site are affiliate links. I made no authenticated calls to AICredits. The API differences come from OpenAI's migration guide, read on 2026-10-16. The model-support figures come from the public catalog fetched the same day.

What does OpenAI say changes?

From the "migrate to Responses" guide:

And the recommendation: Chat Completions "remains supported", but Responses "is recommended for all new projects". You can migrate one flow at a time.

For a broader walkthrough of the newer API, see the OpenAI Responses API guide.

Does a gateway let you use Responses?

Only if the gateway implements it for your model. AICredits' catalog has a supported_apis list on every entry. On 2026-10-16 I counted, among its 378 chat-mode entries:

• 75 listed responses. All 75 were OpenAI models (57 with the openai/ prefix and 18 bare IDs such as gpt-5).
• Every OpenAI chat entry that lacked responses was a newer or open-weight one: openai/gpt-5.6-luna, gpt-5.6-sol, gpt-5.6-terra, gpt-6-astra, gpt-6-astra-pro, gpt-6-luna, gpt-6-sol, gpt-6.1-sol and gpt-oss-120b.
• No non-OpenAI model listed responses.

So at that moment the newest OpenAI models on this gateway could be reached through Chat Completions but, per the catalog, not through Responses. If you move your code to Responses because OpenAI recommends it, a call for openai/gpt-6-luna through this gateway may fail. I did not test that call, since I had no key, so treat the catalog as the claim and your own request as the proof.

Practical rule: write a thin wrapper in your app, choose the API per model from supported_apis, and keep Chat Completions as the fallback.

An adapter for the mechanical changes

This helper converts a Chat Completions request into a Responses-style one. It renames messages to input, moves response_format to text.format, and flattens tool definitions. Two caveats: the guide I read documents the move to text.format but not the fields inside it, and it does not mention the max_tokens rename to max_output_tokens. Those two come from my own knowledge of the API, so verify them against the current reference before you rely on them.

def chat_to_responses(req):
    r = {"model": req["model"], "input": copy.deepcopy(req["messages"])}
    for k in ("temperature", "top_p", "stream"):
        if k in req:
            r[k] = req[k]
    if "max_tokens" in req:
        r["max_output_tokens"] = req["max_tokens"]
    if "tools" in req:
        r["tools"] = [{"type": "function", **t["function"]} for t in req["tools"]]
    rf = req.get("response_format")
    if rf and rf.get("type") == "json_schema":
        js = rf["json_schema"]
        r["text"] = {"format": {"type": "json_schema", "name": js["name"], "schema": js["schema"]}}
    return r

A second function collects assistant text from the output array of a Responses-style object, ignoring non-message items such as reasoning.

I wrote seven unit tests and ran them on 2026-10-16:

test_extract_text ... ok
test_input_not_mutated ... ok
test_input_replaces_messages ... ok
test_max_tokens_renamed ... ok
test_no_message_item_gives_empty_string ... ok
test_response_format_moves_to_text_format ... ok
test_tools_flattened ... ok

Ran 7 tests in 0.001s
OK

These tests check that my adapter does what I intended on hand-written shapes. They do not prove the shapes match OpenAI's live API; for that, run a real request.

What the adapter does not handle

• Multi-turn state. previous_response_id chaining has no Chat Completions equivalent; you must decide whether to keep resending history or rely on stored responses, and think about data retention.
• Streaming. Responses streams typed events rather than choices deltas, so streaming consumers need rewriting.
• Reasoning and tool-call items. They appear as separate Items in output.
• Strictness defaults. The guide says strict mode is attempted when omitted in Responses, which can change how your schemas are validated. Set strict explicitly.

What should you do now?

1. Direct OpenAI, new project: use Responses, as the guide recommends.
2. Gateway, any project: read supported_apis for each model, and keep Chat Completions working. The conformance test checks the Chat Completions path.
3. Existing app: do not rush. Chat Completions remains supported; migrate flow by flow.
4. Build the switch into config so the choice per model is data, not code. See the migration checklist.

To search models and their supported APIs yourself, use the catalog lookup script. The AICredits signup is an affiliate link.

What I could not verify

• Any live call to the Responses API, through AICredits or directly.
• The inner fields of text.format and the max_output_tokens name, which are from memory.
• Whether the catalog's supported_apis matches live behaviour.