---
title: "Paano lumipat mula sa OpenAI API: code diff at test | BroadRouter"
description: "Mga pagbabago sa code mula OpenAI papunta sa OpenAI-compatible API: client setup, Responses sa Chat Completions, tools, streaming, embeddings at smoke test."
url: https://broadrouter.com/fil/blog/migrate-from-openai-api-code-walkthrough/
lang: fil
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/migrate-from-openai-api-code-walkthrough/) (na-update noong 2026-11-15).

# Paglipat mula sa OpenAI API: code walkthrough sa Python, Node, cURL

Ng BroadNet Inference team · 6 minutong basa · Nailathala 2026-11-15

Palitan ang base URL, API key at model ID ng client. Sapat na iyon para sa mga Chat Completions call. Kailangang isulat ulit sa Chat Completions ang code na nasa Responses API: nagiging messages ang input, nagiging choices\[0\].message.content ang output\_text, at nababawasan ng isang level ng nesting ang tools. Panatilihin ang embeddings sa hiwalay na client kung wala nito ang bagong provider, saka magpatakbo ng smoke test bago ilipat ang traffic.

## Mga pangunahing punto

-   Para sa Chat Completions code, tatlong value lang ang papalitan: base\_url, api\_key at model. Binabasa rin ng parehong opisyal na SDK ang OPENAI\_BASE\_URL at OPENAI\_API\_KEY mula sa environment.
-   Inililipat ng pag-set ng OPENAI\_BASE\_URL ang bawat call, kasama ang embeddings. Kung walang embeddings endpoint ang bagong provider, bigyan ng sariling client ang embeddings.
-   Kailangang isulat ulit ang Responses API code: input papuntang messages, instructions papuntang system message, text.format papuntang response\_format, at flat na tool definitions papuntang nested.
-   Dinodokumento ng BroadNet Inference ang /v1/chat/completions, /v1/audio/transcriptions at GET /v1/models, at walang embeddings, files o batch endpoint. Nakalista sa docs nito ang tools at structured output para sa GLM 5.3 at Qwen3.8 27B.
-   Mag-test bago lumipat: simpleng chat, streaming usage, reasoning budget at isang maling key, dagdag ang isang tool call kung gumagamit ka ng tools.

**Sa page na ito**

1.  Ano ang nagbabago sa client setup?
2.  Paano kung Responses API ang gamit ng code ko?
3.  Paano nagbabago ang mga tool call?
4.  Paano naman ang structured output?
5.  Ano ang mangyayari sa embeddings?
6.  Paano nagbabago ang streaming code?
7.  Nagbabago ba ang error handling at retries?
8.  Aling mga parameter ang iba ang behavior?
9.  Paano i-test ang paglipat?
10.  Ano ang pinakamadalas masira?
11.  Saan pumapasok ang BroadNet Inference

Maliit na pagbabago sa code ang paglipat ng app mula OpenAI papunta sa isang OpenAI-compatible provider kung Chat Completions ang gamit mo, at rewrite naman kung Responses API. Ipinapakita ng post na ito ang eksaktong mga diff sa Python, Node at cURL, kung ano ang gagawin sa Responses, tools, structured output at embeddings, at isang smoke test na patatakbuhin bago mo ilipat ang anumang traffic. BroadNet Inference sa `https://inference.broadnet.ai/v1` ang gamit sa mga halimbawa; pareho ang mga hakbang para sa anumang provider.

Ito ang code na kasama ng [migration checklist](https://broadrouter.com/fil/blog/openai-compatible-api-migration-checklist/), na sumasaklaw sa rate limit, errors at pagpaplano ng cutover. Para sa base URL ng ibang provider, tingnan ang [mga OpenAI-compatible base URL, sinuri](https://broadrouter.com/fil/blog/openai-compatible-api-base-urls/).

## Ano ang nagbabago sa client setup?

Tatlong value: base URL, API key at model ID.

**Python**

```python
import os
from openai import OpenAI

# before: client = OpenAI()  # reads OPENAI_API_KEY, calls api.openai.com
client = OpenAI(
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
)
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",          # was e.g. "gpt-..."
    messages=[{"role": "user", "content": "Reply with one short sentence."}],
)
print(r.choices[0].message.content)
```

**Node**

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://inference.broadnet.ai/v1",
  apiKey: process.env.BROADNET_API_KEY,
});
const r = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Reply with one short sentence." }],
});
console.log(r.choices[0].message.content);
```

**cURL**

```bash
curl https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","messages":[{"role":"user","content":"Reply with one short sentence."}]}'
```

Pansinin ang path: nagtatapos na sa `/v1` ang base URL, kaya `/chat/completions` ang idinadagdag ng SDK. Ang pagdodoble ng `/v1` ang pinakakaraniwang unang error.

### Puwede ba akong lumipat nang hindi ginagalaw ang code?

Oo, para sa Chat Completions code. Binabasa ng Python SDK ang `OPENAI_BASE_URL` kapag walang ipinasang `base_url`, at `process.env['OPENAI_BASE_URL']` ang default na `baseURL` ng Node client. Parehong binabasa ang `OPENAI_API_KEY`. Inililipat ng pag-set ng dalawang environment variable ang bawat call.

Iyan din ang panganib. **Bawat call** ang lumilipat, kasama ang embeddings, moderation, file upload at anumang iba pa na puwedeng wala sa bagong provider. Gamitin lang ang environment switch kapag chat call lang ang ginagawa ng app mo at wala nang iba.

## Paano kung Responses API ang gamit ng code ko?

Tinatawag na ngayon ng mga README ng SDK ng OpenAI ang Responses API bilang pangunahing API; tinatawag naman ng Python README ang Chat Completions na “the previous standard (supported indefinitely)” (salin: ang dating standard (suportado nang walang katapusan)). Maraming compatible provider ang Chat Completions lang ang ipinapatupad. Dinodokumento ng BroadNet ang `POST /v1/chat/completions` at `POST /v1/audio/transcriptions`, kaya kailangang isulat ulit ang mga Responses call. Ang katumbasan:

| Responses API | Chat Completions |
| --- | --- |
| `client.responses.create(...)` | `client.chat.completions.create(...)` |
| `instructions="..."` | Unang mensahe `{"role": "system", "content": "..."}` |
| `input="..."` o listahan ng items | `messages=[...]` |
| `response.output_text` | `response.choices[0].message.content` |
| `max_output_tokens` | `max_tokens` (docs ng BroadNet) o `max_completion_tokens` |
| `text={"format": {...}}` | `response_format={...}` |
| `previous_response_id`, conversations | Ikaw mismo ang magpapadala ulit ng buong message history |
| Tool `{"type": "function", "name": ...}` | Tool `{"type": "function", "function": {"name": ...}}` |
| Output item na `function_call`, sagot gamit ang `function_call_output` at `call_id` | `message.tool_calls`, sagot gamit ang role na `tool` at `tool_call_id` |
| Built-in na tools (web search, file search) | Hindi available; patakbuhin ang sarili mong tool |

Ang bago at pagkatapos para sa isang simpleng call:

```python
# Before: Responses API
r = client.responses.create(model="gpt-...", instructions="Be brief.", input="What is RAG?")
text = r.output_text

# After: Chat Completions
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",
    messages=[{"role": "system", "content": "Be brief."},
              {"role": "user", "content": "What is RAG?"}],
)
text = r.choices[0].message.content
```

Ang pinakamalaking pagbabago sa istruktura ay ang state. Puwedeng itago ng Responses ang conversation state sa panig ng OpenAI gamit ang `previous_response_id`. Walang server-side state ang Chat Completions, kaya ang code mo ang nag-iimbak ng listahan ng mensahe at nagpapadala ng lahat ng ito sa bawat turn. Isama iyan sa budget: input token ang buong history sa bawat call.

## Paano nagbabago ang mga tool call?

Sa Chat Completions, naka-nest ang function sa ilalim ng `function` key sa isang tool definition, at ibinabalik ang sagot bilang `tool` message:

```python
import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order",
        "description": "Look up an order by ID.",
        "parameters": {"type": "object",
                       "properties": {"order_id": {"type": "string"}},
                       "required": ["order_id"]},
    },
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
msg = r.choices[0].message
if msg.tool_calls:
    messages.append(msg)                                   # keep the assistant turn
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)         # a JSON string: parse and validate it
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps(lookup_order(args["order_id"]))})
    r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
```

Mas mahalaga ang model kaysa sa hugis. Para lang sa [GLM 5.3](https://broadrouter.com/fil/models/glm-5.3/) at [Qwen3.8 27B](https://broadrouter.com/fil/models/qwen3.8-27b/) nakalista ang tools sa docs ng BroadNet. Huwag ituro ang isang tool loop sa model na walang nakalistang tools sa docs nito, at i-validate ang mga argument bago magpatakbo ng kahit ano. May buong validating loop sa [tool calling gamit ang mga open model](https://broadrouter.com/fil/blog/tool-calling-open-models/).

## Paano naman ang structured output?

Parehong nagpapadala ng `response_format` na may JSON schema ang `client.chat.completions.parse(..., response_format=MyPydanticModel)` at ang `zodResponseFormat` ng Node. Gumagana lang ang mga ito kung tinatanggap ng provider ang hugis na iyon sa model na iyon. Nakalista sa BroadNet ang structured output para sa GLM 5.3 at Qwen3.8 27B pero hindi nito pinapangalanan ang request parameter. Patakbuhin ang four-step na test sa [JSON mode vs json\_schema](https://broadrouter.com/fil/blog/structured-output-json-schema/) nang isang beses kada model, at patuloy na i-validate ang na-parse na resulta anuman ang ipangako ng provider.

## Ano ang mangyayari sa embeddings?

Kung binago mo ang base URL sa isang shared na client at walang embeddings endpoint ang provider, papalya ang bawat `client.embeddings.create` call. Hindi nagbebenta ng [embeddings](https://broadrouter.com/fil/glossary/embeddings/) ang BroadNet. Gumamit ng dalawang client:

```python
chat = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
embed = OpenAI(api_key=os.environ["OPENAI_API_KEY"])   # or any embeddings provider

vec = embed.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding
answer = chat.chat.completions.create(model="broadnet/glm-5.3", messages=build_prompt(query, search(vec)))
```

Huwag kailanman paghaluin sa iisang index ang mga vector mula sa dalawang embedding model. Kung magpapalit ka rin ng embedding provider, i-embed ulit ang buong corpus. Kinukuwenta ng [embedding cost calculator](https://broadrouter.com/tools/embedding-cost-calculator/) ang presyo niyan.

Ganoon din sa anumang hindi chat: image generation, text-to-speech, moderation, ang Batch API at file storage. Wala sa mga ito ang inaalok ng BroadNet. Lumilipat naman ang speech-to-text: gumagana ang `client.audio.transcriptions.create` laban sa `/v1/audio/transcriptions` gamit ang WAV o MP3 at isang `language` field ([gabay sa Arabic speech-to-text](https://broadrouter.com/fil/guides/arabic-speech-to-text-api/)).

## Paano nagbabago ang streaming code?

Nag-i-stream ang Responses API ng mga typed event, gaya ng `response.output_text.delta` at `response.completed`. Chunks naman ang ini-stream ng Chat Completions, at nasa `choices[0].delta.content` ang text. Hindi ipinapadala ang usage maliban kung hihingin mo, at kapag hiningi, dumarating ito sa huling chunk na may walang lamang `choices` list.

```javascript
// Before (Responses): for await (const e of stream) if (e.type === "response.output_text.delta") out(e.delta);
const stream = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Count from one to three." }],
  stream: true,
  stream_options: { include_usage: true },
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log("\ntokens:", chunk.usage.total_tokens);   // last chunk
}
```

Dalawang gawi ang nagpapanatiling ligtas sa stream code pagkatapos lumipat. Bantayan ang `choices[0]`, dahil walang choices ang usage chunk. At ituring na hindi kumpleto ang stream na natapos bago ang huling linyang `data: [DONE]`; sinasabi ng docs ng BroadNet na i-record ang `X-Request-ID` at magpasya kung ligtas ang bagong request. Nasa [streaming chat completions](https://broadrouter.com/fil/guides/streaming-chat-completions/) ang buong pattern sa Python.

## Nagbabago ba ang error handling at retries?

Pareho pa rin ang mga error class ng SDK: `AuthenticationError` para sa 401, `RateLimitError` para sa 429, `APIStatusError` para sa iba. Ang nagbabago ay kung ano ang ibig sabihin ng bawat status sa bagong provider. Sa BroadNet, puwedeng ang ibig sabihin ng 401 ay ubos na ang pay-as-you-go allowance, hindi lang maling key, at ang 402 ay kulang ang balance para sa isang pagbili. Hindi maaayos ng retry ang alinman sa dalawa. Puwedeng galing sa rate, concurrency, token-rate o spend limit ang 429. I-retry ang 429 at 5xx gamit ang backoff, at ayusin ang lahat ng iba. Nasa [gabay sa errors at retries](https://broadrouter.com/fil/guides/errors-and-retries/) ang buong table.

Nire-retry ng SDK ang connection error, 408, 409, 429 at 5xx nang dalawang beses by default. Kung magdadagdag ka ng sarili mong retry loop, i-set ang `max_retries=0` sa client para hindi magpatong ang dalawa.

## Aling mga parameter ang iba ang behavior?

| Parameter | Ano ang i-check |
| --- | --- |
| `max_tokens` / `max_completion_tokens` | Dine-deprecate ng OpenAI ang `max_tokens`; ito ang ginagamit ng docs ng BroadNet. Sa mga reasoning model, kasama rito ang pag-iisip, kaya walang lamang sagot ang ibinabalik ng maliliit na value ([bakit](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/)) |
| `reasoning_effort` | `low` ang dinodokumento ng BroadNet; i-test ang ibang value bago umasa sa mga ito |
| `stream_options: {"include_usage": true}` | Dinodokumento ng BroadNet; dumarating ang usage sa huling chunk |
| `n`, `logprobs`, `seed`, `logit_bias` | Wala sa docs ng BroadNet; i-test, o alisin |
| `store`, `metadata` | Mga storage feature ng OpenAI; tanggalin |
| `image_url` content parts | Sa mga model lang na nakalistang may larawan: DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B |

## Paano i-test ang paglipat?

Magpatakbo ng maikling smoke test laban sa bagong provider bago ilipat ang anumang traffic. Chine-check nito ang simpleng chat, streaming usage, reasoning budget at authentication. Magdagdag ng tool-call na kaso kung gumagamit ka ng tools.

```python
import os, openai
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)
FAST, REASONING = "broadnet/gemma-4-26b-a4b", "broadnet/qwen3.8-27b"
msg = [{"role": "user", "content": "Reply with the word ok."}]

# 1. Plain chat returns text and usage
r = client.chat.completions.create(model=FAST, messages=msg)
assert r.choices[0].message.content and r.usage.prompt_tokens > 0

# 2. Streaming reports usage in the last chunk
chunks = list(client.chat.completions.create(model=FAST, messages=msg, stream=True,
                                             stream_options={"include_usage": True}))
assert chunks[-1].usage is not None

# 3. A reasoning model needs room: a tiny budget can come back empty
r = client.chat.completions.create(model=REASONING, messages=msg, max_tokens=2000)
assert r.choices[0].finish_reason == "stop" and r.choices[0].message.content

# 4. A bad key raises AuthenticationError (401), which you should not retry
bad = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key="invalid", max_retries=0)
try:
    bad.chat.completions.create(model=FAST, messages=msg)
    raise AssertionError("expected 401")
except openai.AuthenticationError:
    pass
print("smoke test passed")
```

Pagkatapos, ikumpara ang kalidad, hindi lang ang hugis. I-replay ang sample ng totoong mga prompt sa parehong provider at i-score ang mga sagot; ipinapakita ng [i-evaluate ang LLM bago lumipat](https://broadrouter.com/fil/blog/evaluate-llm-before-switching/) kung paano. Tinutulungan ka ng [OpenAI to BroadNet migration tool](https://broadrouter.com/tools/openai-to-broadnet-migration/) na isulat ulit ang isang snippet at inililista nito kung aling mga feature ang ginagamit nito.

## Ano ang pinakamadalas masira?

-   **Isang global na base URL** na naglilipat din sa embeddings at file call.
-   **Mga helper na para lang sa Responses** gaya ng `output_text` na naiwan sa code na tumatawag na ngayon sa Chat Completions.
-   **Mga model ID.** Wala sa ibang lugar ang mga pangalang `gpt-...`. Sa BroadNet, ganito ang hitsura nila: `broadnet/glm-5.3`.
-   **Walang lamang sagot** mula sa mga reasoning model na maliit ang `max_tokens`.
-   **Mga rate limit.** Ang pay-as-you-go key ng BroadNet ay may 30 request kada minuto at 4 in flight. Kailangan ng queue ang mga bulk job ([paghawak ng 429](https://broadrouter.com/fil/blog/handle-llm-api-429-rate-limits/)).

## Saan pumapasok ang BroadNet Inference

Bagay ang BroadNet Inference sa mga app na chat at transcription ang gamit sa OpenAI: mga assistant, extraction, pag-summarize, translation at Arabic na pananalita. Bagay rin ito sa mga app na gusto ng flat-rate na [DeepSeek V4.1 Flash](https://broadrouter.com/fil/models/deepseek-v4.1-flash/) plan para sa mga agent. Hindi ito ang tamang target kung umaasa ka sa server-side state ng Responses API, built-in na tools, embeddings, image generation, text-to-speech, realtime voice o Batch API. Ilipat ang mga iyon sa mga provider na nag-aalok nito, o panatilihin sa OpenAI at ang mga chat call lang ang ilipat. Tumatakbo sa $5 na panimulang credit ang Gemma 4 VL 26B at ang parehong transcription model; kailangan munang mag-top up para sa GLM 5.3, Qwen3.8 27B at DeepSeek V4.1 Flash.

Mga libreng tool para rito (Ingles)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[Embeddings](https://broadrouter.com/fil/glossary/embeddings/)

Ang embeddings ay mga listahan ng floating-point na numero (vector) na binubuo ng isang model para kumatawan sa isang piraso ng text, larawan o ibang input. Magkakalapit ang vector ng mga input na magkatulad ang kahulugan, kaya magagamit ang layo ng mga vector para i-rank ang search results, i-cluster ang mga dokumento o hanapin ang magkakaugnay na item.

[Chat Completions API](https://broadrouter.com/fil/glossary/chat-completions-api/)

Ang Chat Completions API ay HTTP endpoint ng OpenAI, POST /v1/chat/completions, na tumatanggap ng pangalan ng model at listahan ng mga message na may role, at ibinabalik ang susunod na message ng model. Ang hugis ng request at response nito ang naging karaniwang format na ginagamit din ng mga OpenAI-compatible na provider at SDK.

[Tool calling (function calling)](https://broadrouter.com/fil/glossary/tool-calling/)

Ang tool calling, tinatawag ding function calling, ay feature ng LLM API kung saan nagbabalik ang model ng structured na request para magpatakbo ng function na tinukoy ng developer, kasama ang JSON arguments. Ang application ang nagpapatakbo ng function at nagpapadala pabalik ng resulta; hindi kailanman nagpapatakbo ng code ang model mismo.

[Base URL](https://broadrouter.com/fil/glossary/base-url/)

Ang base URL ay ang fixed na root address ng isang API, gaya ng https://api.example.com/v1, na idinudugtong ng client sa unahan ng bawat endpoint path, gaya ng /chat/completions. Sa mga OpenAI-compatible SDK, kapag pinalitan ang base URL, kasama ang API key at model ID, sa ibang provider na tatawag ang parehong code.

[API key](https://broadrouter.com/fil/glossary/api-key/)

Ang API key ay isang lihim na string na kumikilala at nagpapahintulot sa client na tumatawag sa isang API. Kadalasang hinihingi ito ng mga LLM API sa Authorization: Bearer header, at ang sinumang may hawak ng key ay makakagawa ng mga request na sisingilin sa account na may-ari nito.

[Pay-as-you-go](https://broadrouter.com/fil/glossary/pay-as-you-go/)

Ang pay-as-you-go ay paraan ng pagpepresyo kung saan ang nagamit mo lang ang binabayaran mo, sinusukat kada yunit gaya ng token, request o minuto ng audio, nang walang subscription o minimum na commitment. Ganito naniningil ang karamihan ng LLM API, mula sa prepaid na balance o sa pana-panahong invoice.

[Speech-to-text (STT)](https://broadrouter.com/fil/glossary/speech-to-text/)

Ang speech-to-text, na tinatawag ding automatic speech recognition (ASR), ay teknolohiyang ginagawang nakasulat na text ang binigkas na audio. Tumatanggap ang speech-to-text API ng audio file o stream at nagbabalik ng transcript, kadalasang may presyo kada minuto ng audio. Sinusukat ang accuracy gamit ang word error rate, at nag-iiba ito ayon sa accent, dialect at kalidad ng recording.

[Rate limit](https://broadrouter.com/fil/glossary/rate-limit/)

Ang rate limit ay hangganang itinatakda ng API sa dami ng paggamit ng isang client sa isang yugto ng oras, gaya ng request kada minuto o token kada minuto. Tinatanggihan ang mga request na lampas sa limit, kadalasan na may HTTP 429 Too Many Requests, hanggang bumaba ulit ang paggamit.

## Mga tanong

### Kailangan ko ba ng ibang SDK para gumamit ng OpenAI-compatible API?

Hindi. Panatilihin ang opisyal na openai package at magpasa ng ibang base\_url (Python) o baseURL (Node), dagdag ang key ng bagong provider. Pareho pa rin ang request at response object para sa mga endpoint na sinusuportahan ng provider.

### Sinusuportahan ba ng OpenAI-compatible API ang Responses API?

May ilan; marami ang Chat Completions lang ang sinusuportahan. I-check ang listahan ng endpoint ng provider. Dinodokumento ng BroadNet Inference ang /v1/chat/completions at /v1/audio/transcriptions, kaya kailangang isulat ulit sa Chat Completions ang Responses code.

### Ano ang mangyayari sa embeddings ko kapag lumipat ako?

Masisira ang mga ito kung walang embeddings endpoint ang bagong provider at binago mo ang base URL nang global. Hindi nagbebenta ng embeddings ang BroadNet, kaya panatilihin ang isang embeddings client na nakaturo sa embeddings provider mo. Huwag kailanman paghaluin sa iisang index ang mga vector mula sa dalawang embedding model.

### max\_tokens ba o max\_completion\_tokens ang dapat kong ipadala?

Minamarkahan ng OpenAI na deprecated ang max\_tokens pabor sa max\_completion\_tokens. Maraming compatible provider ang max\_tokens ang dinodokumento, at max\_tokens ang ginagamit ng docs ng BroadNet. Ipadala ang dinodokumento ng provider at kumpirmahin sa smoke test na gumagana ang limit.

### Gagana pa ba ang structured output helpers ng OpenAI?

Kung tumatanggap lang ang provider ng response\_format na may json\_schema sa model na ginagamit mo. Nakalista sa BroadNet ang structured output para sa GLM 5.3 at Qwen3.8 27B pero hindi nito pinapangalanan ang request parameter, kaya i-test ito, at patuloy na i-validate ang na-parse na resulta.

## Magbasa pa

-   [Paglipat sa OpenAI-compatible API: checklist sa migration](https://broadrouter.com/fil/blog/openai-compatible-api-migration-checklist/)
-   [Base URL ng OpenAI-compatible API: 14 na provider, sinuri](https://broadrouter.com/fil/blog/openai-compatible-api-base-urls/)
-   [Tool calling sa open model: schema, parallel call, retry](https://broadrouter.com/fil/blog/tool-calling-open-models/)
-   [JSON mode vs json\_schema: structured output na maaasahan](https://broadrouter.com/fil/blog/structured-output-json-schema/)
-   [Paano mag-evaluate ng LLM bago lumipat ng provider](https://broadrouter.com/fil/blog/evaluate-llm-before-switching/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [I-cache ang LLM API response, makatipid: exact-match cache sa Python](https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)
-   [Gabay: Paano gamitin ang OpenAI Node.js SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-node-sdk/)
-   [Gabay: Paano gamitin ang curl sa BroadNet Inference: ang una mong request](https://broadrouter.com/fil/guides/curl-quickstart/)
-   [Gabay: Bakit walang laman ang sagot ng isang reasoning model](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

[Magsimula](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-migrate-from-openai-api-code-walkthrough&utm_content=page-cta) ·

**Mga source**

-   [API reference ng BroadNet Inference: endpoints, model ID, kakayahan, streaming usage, errors (sinuri noong 2026-11-15) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-migrate-from-openai-api-code-walkthrough&utm_content=sources)
-   [README ng openai-python: Responses ang pangunahing API, suportado nang walang katapusan ang Chat Completions, retries (sinuri noong 2026-11-15)](https://github.com/openai/openai-python)
-   [Source ng openai-node client: OPENAI\_BASE\_URL ang default ng baseURL (sinuri noong 2026-11-15)](https://github.com/openai/openai-node/blob/master/src/client.ts)
-   [OpenAI, Migrate to the Responses API: pagkakaiba sa structured output, tools at storage (sinuri noong 2026-11-15)](https://developers.openai.com/api/docs/guides/migrate-to-responses)
-   [Function calling guide ng OpenAI: hugis ng tool sa parehong API (sinuri noong 2026-11-15)](https://developers.openai.com/api/docs/guides/function-calling)
-   [Chat Completions reference ng OpenAI: deprecated ang max\_tokens pabor sa max\_completion\_tokens (sinuri noong 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
