---
title: "JSON mode vs JSON schema sa structured output, may code"
description: "Valid na JSON ang bigay ng JSON mode; ang hugis mo ang bigay ng json_schema. Paano hingin ang bawat isa, i-validate gamit ang Pydantic, at ayusin ang maling output."
url: https://broadrouter.com/fil/blog/structured-output-json-schema/
lang: fil
updated: 2026-11-14
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/structured-output-json-schema/) (na-update noong 2026-11-14).

# JSON mode vs json\_schema: structured output na maaasahan

Ng BroadNet Inference team · 4 minutong basa · Nailathala 2026-11-14

Valid na JSON lang ang ipinapangako ng JSON mode (response\_format json\_object). Ipinapangako rin ng structured output (response\_format json\_schema) ang mga field at type mo, kung ipinapatupad ito ng provider. Alinman dito, i-check ang finish\_reason, i-parse, at i-validate laban sa isang schema gaya ng Pydantic model. Kung pumalya ang validation, ibalik ang error at humingi ulit, na may mahigpit na limit sa bilang ng subok.

## Mga pangunahing punto

-   Ayon sa guide ng OpenAI, parehong mode ay gumagawa ng valid na JSON, pero "only Structured Outputs ensure schema adherence" (salin: Structured Outputs lang ang tumitiyak na sinusunod ang schema).
-   Iba-iba ang suporta sa mga OpenAI-compatible provider. I-test muna ang json\_schema, saka bumalik sa json\_object, saka sa prompt lang.
-   I-validate ang bawat sagot. Sirang JSON ang sagot na naputol dahil sa max\_tokens, anuman ang sabihin ng schema.
-   Gumagana ang repair loop kapag ibinabalik mo ang eksaktong validation error. Limitahan ito sa dalawa o tatlong subok.
-   Sa BroadNet Inference, nakalista ang structured output para sa GLM 5.3 at Qwen3.8 27B.

**Sa page na ito**

1.  Ano ang pagkakaiba ng JSON mode at json\_schema?
2.  Paano humingi ng json\_schema?
3.  Aling mode ang sinusuportahan ng provider mo?
4.  Paano i-validate at ayusin ang maling output?
5.  Aling mga feature ng schema ang nagdudulot ng problema?
6.  Paano i-monitor ang structured output sa production?
7.  Kailan mas mabuting gumamit ng tool?
8.  Saan pumapasok ang BroadNet Inference

Data ang kailangan ng code mo, at text ang isinusulat ng mga model. Pinagdudugtong ng [structured output](https://broadrouter.com/fil/glossary/structured-output/) ang dalawa, pero tatlong magkakaibang bagay ang ibig sabihin ng “nagbabalik ng JSON ang model” depende sa kung paano ka humingi. Ikinukumpara ng post na ito ang mga opsyon sa mga OpenAI-compatible na open model, ipinapakita kung paano hingin ang bawat isa, at nagbibigay ng validate-and-repair loop na puwede mong ilagay agad sa production.

## Ano ang pagkakaiba ng JSON mode at json\_schema?

| Paraan | Request | Ano ang ipinapangako sa iyo |
| --- | --- | --- |
| Prompt lang | “Sumagot sa JSON na may mga field na…” | Wala; kadalasan JSON, minsan may sobrang text |
| JSON mode | `response_format: {"type": "json_object"}` | Valid na JSON, kahit anong hugis |
| Structured output | `response_format: {"type": "json_schema", ...}` | JSON na tugma sa schema mo, kung ipinapatupad |

Diretsahan ito sa Structured Outputs guide ng OpenAI: “While both ensure valid JSON is produced, only Structured Outputs ensure schema adherence.” (salin: Bagama’t parehong tinitiyak na valid na JSON ang nagagawa, Structured Outputs lang ang tumitiyak na sinusunod ang schema.) Inirerekomenda nito ang structured output kaysa JSON mode kung posible.

Sa mga provider ng open model, nakadepende ang garantiya sa kung paano ito ipinatupad ng server. Marami ang gumagamit ng constrained decoding, na hinaharangan ang mga token na sisira sa schema. May iba na tumatanggap ng field pero hindi ito ipinapatupad. Kaya nagva-validate pa rin ang code sa ibaba, anuman ang mangyari.

## Paano humingi ng json\_schema?

```python
import os
from openai import OpenAI
from pydantic import BaseModel, Field

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

class Invoice(BaseModel):
    vendor: str
    currency: str = Field(pattern="^[A-Z]{3}$")
    total: float
    line_items: list[float]

schema = Invoice.model_json_schema()
schema["additionalProperties"] = False

response_format = {"type": "json_schema",
                   "json_schema": {"name": "invoice", "strict": True, "schema": schema}}
```

Ginagawa ng Pydantic ang JSON Schema mula sa class mo, kaya hindi kailanman magkakalayo ang schema at ang validator. Kung hindi ka gumagamit ng Pydantic, gumagawa ang [JSON schema generator](https://broadrouter.com/tools/json-schema-generator/) ng strict-mode na schema mula sa isang sample na object. Para sa strict mode, hinihingi ng OpenAI ang `additionalProperties: false` at na nakalistang required ang bawat property.

## Aling mode ang sinusuportahan ng provider mo?

Patakbuhin ang test na ito nang isang beses kada model bago ka mag-build dito:

1.  Magpadala ng `json_schema` na may prompt na nag-iimbita ng sobrang field (“magdagdag ka rin ng maikling komento”).
2.  Kung nag-error ang request, hindi tumatanggap ng `json_schema` ang provider. Subukan ang `json_object`.
3.  Kung may sobrang field ang sagot, hindi ipinapatupad ang schema. Ituring itong JSON mode.
4.  Kung nag-error din ang `json_object`, gumamit ng prompt lang na may validation.

Sa BroadNet Inference, nakalista sa docs ang structured output para sa [GLM 5.3](https://broadrouter.com/fil/models/glm-5.3/) at [Qwen3.8 27B](https://broadrouter.com/fil/models/qwen3.8-27b/) ([magkatabing paghahambing](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/)), pero hindi nito pinapangalanan ang request parameter. Patakbuhin ang test sa itaas sa model na isi-ship mo.

## Paano i-validate at ayusin ang maling output?

```python
import json
from pydantic import ValidationError

def extract(text: str, model="broadnet/glm-5.3", attempts=3) -> Invoice:
    messages = [
        {"role": "system", "content": "Extract the invoice. Reply with JSON only."},
        {"role": "user", "content": text},
    ]
    for attempt in range(attempts):
        r = client.chat.completions.create(model=model, messages=messages,
                                           response_format=response_format,
                                           max_tokens=4000)
        choice = r.choices[0]
        if choice.finish_reason == "length":
            raise RuntimeError("Cut off: raise max_tokens")  # retrying won't help
        if getattr(choice.message, "refusal", None):
            raise RuntimeError(f"Refused: {choice.message.refusal}")
        raw = choice.message.content or ""
        try:
            inv = Invoice.model_validate_json(raw)
            if abs(sum(inv.line_items) - inv.total) > 0.01:
                raise ValueError("total must equal the sum of line_items")
            return inv
        except (ValidationError, ValueError) as e:
            messages += [
                {"role": "assistant", "content": raw},
                {"role": "user", "content": f"That JSON is invalid: {e}. Return corrected JSON only."},
            ]
    raise RuntimeError(f"No valid JSON after {attempts} attempts")
```

Ito ang nagpapagana sa loop na ito:

-   **Unahing i-check ang `finish_reason`.** Putol na JSON ang sagot na tumama sa [`max_tokens`](https://broadrouter.com/fil/glossary/max-tokens/). Papalya rin sa parehong paraan ang retry na may parehong limit. Parehong nagre-reason ang dalawang model sa itaas bago sumagot, at [binibilang ang reasoning sa limit](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/), kaya mag-iwan ng puwang.
-   **Hiwalay na hawakan ang refusal.** Sinasabi ng guide ng OpenAI na ang refusal ay “does not necessarily follow the schema you have supplied” (salin: hindi kinakailangang sumusunod sa schema na ibinigay mo).
-   **Ibalik ang eksaktong error.** Kadalasan, ibinabalik ng bulag na retry ang parehong mali. May maaayos ang model kapag binigyan mo ng “line\_items: field required”.
-   **I-check sa code ang mga business rule.** Hindi masasabi ng schema na dapat katumbas ng total ang kabuuan ng line items nito. Kaya iyon ng check sa itaas.
-   **Limitahan ang bilang ng subok.** Ipinapadala ulit ng bawat subok ang buong prompt bilang [input token](https://broadrouter.com/fil/glossary/input-and-output-tokens/).

## Aling mga feature ng schema ang nagdudulot ng problema?

Panatilihing simple ang mga schema:

1.  **Mas mabuti ang flat kaysa nested.** Sapat na ang dalawang level para sa karamihan ng extraction.
2.  **Enum imbes na malayang string** para sa mga kategorya.
3.  **Walang open-ended na object.** Tinatalo ng mga free-form na `dict` field ang layunin.
4.  **Maiikling pangalan ng field na may description.** Ginagabayan ng mga description sa schema ang model.
5.  **Nullable ang mga optional na field.** Sa strict mode, ilista ang bawat field bilang required at payagan ang `null`.

Sinasabi ng guide ng OpenAI na may ilang feature ng JSON Schema na hindi suportado sa strict mode. May sarili ring limit ang mga server ng open model. Kung tinanggihan ang isang schema, pasimplehin muna ito bago magpalit ng mode.

## Paano i-monitor ang structured output sa production?

Puwedeng itago ng loop na tahimik na nag-aayos ang isang problemang gumagastos sa iyo ng token araw-araw. Mag-log ng tatlong numero kada call site:

| Metric | Ano ang sinasabi nito sa iyo |
| --- | --- |
| Success rate sa unang subok | Gaano kabagay ang model at schema; madalas bumaba ito pagkatapos magbago ang prompt o model |
| Average na bilang ng subok kada tagumpay | Ang gastos sa token ng mga repair |
| Mga huling failure | Mga input na hindi kaya ng pipeline mo; suriin ang mga ito nang mano-mano |

Kung bumaba ang success sa unang subok kumpara sa nakasanayan mo, pasimplehin ang schema o sumubok ng ibang model bago ka magdagdag ng mas maraming retry. Magtabi ng sample ng mga raw na sagot na pumalya, para ma-test mo ang mga ayos laban sa totoong mga kaso.

## Kailan mas mabuting gumamit ng tool?

Gamitin ang structured output para sa **huling sagot**: isang extraction, isang classification, isang plano. Gamitin ang [tool calling](https://broadrouter.com/fil/blog/tool-calling-open-models/) kapag kailangan ng model na may **gawin** ang code mo at saka magpatuloy. Maraming agent ang gumagamit ng dalawa: tools habang nasa loop, schema para sa huling hakbang. Para sa halimbawa ng image-to-JSON, tingnan ang [pagbasa ng mga Arabic invoice gamit ang vision model](https://broadrouter.com/fil/guides/read-arabic-invoices-with-vision/).

## Saan pumapasok ang BroadNet Inference

Nakalista sa BroadNet Inference ang structured output para sa GLM 5.3 at Qwen3.8 27B, sa likod ng standard na chat-completions format, kaya tumatakbo ang code sa itaas gamit ang [OpenAI Python SDK](https://broadrouter.com/fil/guides/openai-python-sdk/) nang walang binabago. Tumatanggap din ng larawan ang Qwen3.8 27B, na bagay sa document extraction. Hindi sinasabi ng docs ng BroadNet na may structured output ang DeepSeek V4.1 Flash o Gemma 4 VL 26B, kaya gamitin doon ang prompt lang na may validation. Ikumpara ang presyo kada token sa [pricing page](https://broadrouter.com/fil/pricing/).

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

[Structured output](https://broadrouter.com/fil/glossary/structured-output/)

Ang structured output ay feature ng LLM API na naglilimita sa sagot ng model sa format na itinakda ng developer, kadalasang JSON Schema, para maaasahang ma-parse ito ng code. Mas mahigpit ito kaysa sa JSON mode, na gumagarantiya ng valid na JSON pero hindi ng partikular na hugis.

[Token](https://broadrouter.com/fil/glossary/token/)

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

[JSON Schema](https://broadrouter.com/fil/glossary/json-schema/)

Ang JSON Schema ay isang vocabulary, nakasulat sa JSON, para ilarawan at i-validate ang istruktura ng JSON data: mga type, required na field, pinapayagang value at nesting. 2020-12 ang kasalukuyang bersyon. Ginagamit ito ng mga LLM API para tukuyin ang tool parameters at ang eksaktong hugis na dapat sundin ng structured output.

[JSON mode](https://broadrouter.com/fil/glossary/json-mode/)

Ang JSON mode ay isang setting ng LLM API, response\_format {"type": "json\_object"} sa mga OpenAI-style na API, na ginagawang valid at nae-parse na JSON ang sagot ng model. Hindi tulad ng structured outputs na may JSON Schema, hindi nito ginagarantiya kung anong mga key, type o value ang laman ng object.

[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.

[Open-weight model](https://broadrouter.com/fil/glossary/open-weight-model/)

Ang open-weight model ay machine learning model na inilathala ang trained weights para i-download at patakbuhin ng kahit sino, kadalasan sa ilalim ng lisensyang may kondisyon. Iba ito sa ganap na open-source AI, na naglalabas din ng training code at detalyadong impormasyon tungkol sa training data para mapag-aralan at ma-reproduce ng iba ang model.

[AI agent](https://broadrouter.com/fil/glossary/agent/)

Ang AI agent ay isang system kung saan ang language model mismo ang nagdidirekta ng mga hakbang nito tungo sa isang layunin: pinipili nito kung aling tools ang tatawagin, binabasa ang mga resulta at umuulit hanggang makabuo ng huling sagot o maabot ang limit. Workflow naman ang karaniwang tawag sa fixed na script na tumatawag sa model sa takdang punto.

[Input at output token (input and output tokens)](https://broadrouter.com/fil/glossary/input-and-output-tokens/)

Ang input token ay ang mga token na binabasa ng language model sa isang request, kasama ang system prompt, history ng usapan, tool definitions at mga larawan. Ang output token ay ang mga token na binubuo nito bilang sagot, kasama ang anumang reasoning. Kadalasang magkahiwalay ang presyo ng dalawa, at mas mahal ang output.

## Mga tanong

### Ano ang pagkakaiba ng JSON mode at structured output?

Ang JSON mode, response\_format type json\_object, ay nangangako lang na mapa-parse bilang JSON ang sagot. Ang structured output, type json\_schema, ay nangangako rin ng mga field at type na itinakda mo, kung ipinapatupad ito ng provider. Inirerekomenda ng OpenAI ang structured output kaysa JSON mode kung posible.

### Sinusuportahan ba ng mga open model ang json\_schema na response\_format?

Depende sa provider. May tumatanggap ng json\_schema, may json\_object lang, at may hindi pinapansin ang field. Magpadala ng test request na may schema at prompt na nanunukso sa model na magdagdag ng sobrang field, saka i-check ang sagot.

### Kailangan ko pa bang i-validate ang structured output?

Oo. Puwedeng maputol ang sagot dahil sa max\_tokens, puwedeng refusal ito, at puwede nitong labagin ang mga business rule na hindi kayang ipahayag ng schema, gaya ng mga total na dapat tumugma.

### Ilang beses ko dapat i-retry ang invalid na JSON?

Kadalasan, sapat na ang dalawa o tatlong subok na kasama ang validation error. Pagkatapos noon, i-log ang input at ipasa ito sa isang fallback, sa mas malakas na model o sa isang tao. Sayang sa token ang loop na walang hangganan.

### Structured output ba o tool calling ang dapat kong gamitin?

Gamitin ang structured output kapag gusto mo ang huling sagot sa isang fixed na hugis. Gamitin ang tool calling kapag kailangan ng model na may gawin ang code mo bago ito magpatuloy.

## Magbasa pa

-   [Arabic text classification gamit ang LLM: sentiment, intent, triage](https://broadrouter.com/fil/blog/arabic-text-classification-llm/)
-   [Tool calling sa open model: schema, parallel call, retry](https://broadrouter.com/fil/blog/tool-calling-open-models/)
-   [Paglipat sa OpenAI-compatible API: checklist sa migration](https://broadrouter.com/fil/blog/openai-compatible-api-migration-checklist/)
-   [n8n AI Agent sa murang LLM: setup, pagpili ng model at gastos kada run](https://broadrouter.com/fil/blog/n8n-ai-agent-cheap-llm/)
-   [Paano ayusin ang invalid JSON mula sa LLM: sanhi, repair, retry](https://broadrouter.com/fil/blog/fix-invalid-json-from-llm/)
-   [Arabic named entity extraction gamit ang LLM: JSON, petsa at check](https://broadrouter.com/fil/blog/arabic-named-entity-extraction-llm/)
-   [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: Basahin ang mga Arabic na invoice at resibo gamit ang vision model](https://broadrouter.com/fil/guides/read-arabic-invoices-with-vision/)
-   [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-structured-output-json-schema&utm_content=page-cta) ·

**Mga source**

-   [OpenAI, Structured Outputs guide (sinuri noong 2026-11-14)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [API reference ng OpenAI, create chat completion (response\_format)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Docs ng Pydantic, JSON Schema at validation](https://docs.pydantic.dev/latest/concepts/json_schema/)
-   [API reference ng BroadNet Inference, mga model (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-structured-output-json-schema&utm_content=sources#models)
