---
title: "JSON mode बनाम JSON schema स्ट्रक्चर्ड आउटपुट, कोड के साथ"
description: "JSON mode वैध JSON देता है; json_schema आपका ढाँचा। OpenAI-कम्पैटिबल मॉडल पर दोनों कैसे माँगें, Pydantic से वैलिडेट करें, और ग़लत आउटपुट लूप में ठीक करें।"
url: https://broadrouter.com/hi/blog/structured-output-json-schema/
lang: hi
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/structured-output-json-schema/) (2026-11-14 को अपडेट किया गया).

# JSON mode बनाम json\_schema: भरोसेमंद स्ट्रक्चर्ड आउटपुट

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित 2026-11-14

JSON mode (response\_format json\_object) सिर्फ़ वैध JSON का वादा करता है। स्ट्रक्चर्ड आउटपुट (response\_format json\_schema) आपके फ़ील्ड और टाइप का भी वादा करता है, जहाँ प्रोवाइडर इसे लागू करता है। दोनों में finish\_reason जाँचें, पार्स करें, और Pydantic मॉडल जैसे स्कीमा से वैलिडेट करें। वैलिडेशन फ़ेल हो, तो एरर वापस भेजकर फिर माँगें, कोशिशों की पक्की सीमा के साथ।

## मुख्य बातें

-   OpenAI की गाइड: दोनों मोड वैध JSON बनाते हैं, लेकिन "only Structured Outputs ensure schema adherence" (अनुवाद: स्कीमा का पालन सिर्फ़ Structured Outputs पक्का करते हैं)।
-   OpenAI-कम्पैटिबल प्रोवाइडर में सपोर्ट अलग-अलग है। पहले json\_schema टेस्ट करें, फिर json\_object पर जाएँ, फिर सिर्फ़ प्रॉम्प्ट पर।
-   हर जवाब वैलिडेट करें। max\_tokens से कटा हुआ जवाब टूटा हुआ JSON है, स्कीमा चाहे कुछ भी कहे।
-   रिपेयर लूप तब काम करते हैं जब आप वैलिडेशन का सटीक एरर वापस भेजते हैं। उन्हें दो या तीन कोशिशों तक सीमित रखें।
-   BroadNet Inference पर GLM 5.3 और Qwen3.8 27B स्ट्रक्चर्ड आउटपुट की सुविधा दिखाते हैं।

**इस पेज पर**

1.  JSON mode और json\_schema में क्या फ़र्क़ है?
2.  json\_schema कैसे माँगें?
3.  आपका प्रोवाइडर कौन-सा मोड सपोर्ट करता है?
4.  ग़लत आउटपुट को वैलिडेट और रिपेयर कैसे करें?
5.  स्कीमा के कौन-से फ़ीचर दिक़्क़त देते हैं?
6.  प्रोडक्शन में स्ट्रक्चर्ड आउटपुट की निगरानी कैसे करें?
7.  इसकी जगह टूल कब इस्तेमाल करें?
8.  BroadNet Inference कहाँ फ़िट होता है

आपके कोड को डेटा चाहिए, और मॉडल टेक्स्ट लिखते हैं। [स्ट्रक्चर्ड आउटपुट](https://broadrouter.com/hi/glossary/structured-output/) यह दूरी पाटता है, लेकिन “मॉडल JSON लौटाता है” के तीन अलग मतलब हैं, इस पर निर्भर करते हुए कि आप कैसे माँगते हैं। यह पोस्ट OpenAI-कम्पैटिबल ओपन मॉडल पर इन विकल्पों की तुलना करती है, हर एक को माँगने का तरीक़ा दिखाती है, और एक वैलिडेट-और-रिपेयर लूप देती है जिसे आप सीधे प्रोडक्शन में लगा सकते हैं।

## JSON mode और json\_schema में क्या फ़र्क़ है?

| तरीक़ा | अनुरोध | आपको किस बात का वादा मिलता है |
| --- | --- | --- |
| सिर्फ़ प्रॉम्प्ट | “इन फ़ील्ड के साथ JSON में जवाब दें…” | किसी बात का नहीं; आम तौर पर JSON, कभी-कभी अतिरिक्त टेक्स्ट के साथ |
| JSON mode | `response_format: {"type": "json_object"}` | वैध JSON, कोई भी ढाँचा |
| स्ट्रक्चर्ड आउटपुट | `response_format: {"type": "json_schema", ...}` | आपके स्कीमा से मेल खाता JSON, जहाँ लागू किया गया हो |

OpenAI की Structured Outputs गाइड यह सीधे कहती है: “While both ensure valid JSON is produced, only Structured Outputs ensure schema adherence.” (अनुवाद: दोनों वैध JSON बनना पक्का करते हैं, लेकिन स्कीमा का पालन सिर्फ़ Structured Outputs पक्का करते हैं।) वह जहाँ भी संभव हो, JSON mode की जगह स्ट्रक्चर्ड आउटपुट की सलाह देती है।

ओपन मॉडल के प्रोवाइडर पर यह गारंटी इस पर निर्भर करती है कि सर्वर इसे कैसे लागू करता है। कई constrained decoding इस्तेमाल करते हैं, जो उन टोकन को रोक देता है जो स्कीमा तोड़ते। कुछ फ़ील्ड स्वीकार तो करते हैं लेकिन उसे लागू नहीं करते। इसीलिए नीचे का कोड हर हाल में वैलिडेट करता है।

## 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}}
```

Pydantic आपकी क्लास से JSON Schema बनाता है, इसलिए स्कीमा और वैलिडेटर कभी अलग नहीं होते। अगर आप Pydantic इस्तेमाल नहीं करते, तो [JSON schema जेनरेटर](https://broadrouter.com/tools/json-schema-generator/) एक सैंपल ऑब्जेक्ट से strict mode वाला स्कीमा बना देता है। strict mode के लिए OpenAI को `additionalProperties: false` चाहिए और हर प्रॉपर्टी required के रूप में सूचीबद्ध होनी चाहिए।

## आपका प्रोवाइडर कौन-सा मोड सपोर्ट करता है?

किसी मॉडल पर कुछ बनाने से पहले यह टेस्ट एक बार चलाएँ:

1.  `json_schema` के साथ ऐसा प्रॉम्प्ट भेजें जो एक अतिरिक्त फ़ील्ड माँगे (“साथ में एक छोटी टिप्पणी भी जोड़ें”)।
2.  अगर अनुरोध एरर देता है, तो प्रोवाइडर `json_schema` स्वीकार नहीं करता। `json_object` आज़माएँ।
3.  अगर जवाब में अतिरिक्त फ़ील्ड है, तो स्कीमा लागू नहीं हो रहा। इसे JSON mode मानें।
4.  अगर `json_object` भी एरर देता है, तो वैलिडेशन के साथ सिर्फ़ प्रॉम्प्ट वाला तरीक़ा इस्तेमाल करें।

BroadNet Inference पर डॉक्यूमेंटेशन [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) और [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) ([आमने-सामने तुलना](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/)) के लिए स्ट्रक्चर्ड आउटपुट दिखाता है, लेकिन अनुरोध का पैरामीटर नहीं बताता। जिस मॉडल को आप प्रोडक्शन में ले जाते हैं, उस पर ऊपर का टेस्ट चलाएँ।

## ग़लत आउटपुट को वैलिडेट और रिपेयर कैसे करें?

```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")
```

यह लूप क्यों काम करता है:

-   **पहले `finish_reason` जाँचें।** जो जवाब [`max_tokens`](https://broadrouter.com/hi/glossary/max-tokens/) तक पहुँच गया, वह कटा हुआ JSON है। उसी सीमा के साथ रीट्राई उसी तरह फ़ेल होगा। ऊपर के दोनों मॉडल जवाब देने से पहले रीज़निंग करते हैं, और [रीज़निंग सीमा में गिनी जाती है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/), इसलिए जगह छोड़ें।
-   **इनकार को अलग से सँभालें।** OpenAI की गाइड बताती है कि इनकार “does not necessarily follow the schema you have supplied” (अनुवाद: ज़रूरी नहीं कि आपके दिए स्कीमा का पालन करे)।
-   **सटीक एरर वापस भेजें।** बिना जानकारी का रीट्राई अक्सर वही ग़लती लौटाता है। “line\_items: field required” मॉडल को ठीक करने के लिए कुछ ठोस देता है।
-   **बिज़नेस नियम कोड में जाँचें।** स्कीमा यह नहीं कह सकता कि टोटल उसके लाइन आइटम के बराबर होना चाहिए। ऊपर की जाँच कह सकती है।
-   **कोशिशें सीमित रखें।** हर कोशिश पूरा प्रॉम्प्ट [इनपुट टोकन](https://broadrouter.com/hi/glossary/input-and-output-tokens/) के रूप में दोबारा भेजती है।

## स्कीमा के कौन-से फ़ीचर दिक़्क़त देते हैं?

स्कीमा सीधे-सादे रखें:

1.  **नेस्टेड से फ़्लैट बेहतर।** ज़्यादातर एक्सट्रैक्शन के लिए दो स्तर काफ़ी हैं।
2.  **कैटेगरी के लिए खुले स्ट्रिंग की जगह enum।**
3.  **कोई खुले-अंत वाले ऑब्जेक्ट नहीं।** फ़्री-फ़ॉर्म `dict` फ़ील्ड पूरा मक़सद ही ख़त्म कर देते हैं।
4.  **विवरण के साथ छोटे फ़ील्ड नाम।** स्कीमा में दिए विवरण मॉडल को राह दिखाते हैं।
5.  **वैकल्पिक फ़ील्ड nullable के रूप में।** strict mode में हर फ़ील्ड को required सूचीबद्ध करें और `null` की अनुमति दें।

OpenAI की गाइड बताती है कि JSON Schema के कुछ फ़ीचर strict mode में सपोर्ट नहीं होते। ओपन मॉडल सर्वर की अपनी सीमाएँ होती हैं। अगर कोई स्कीमा अस्वीकार हो जाए, तो मोड बदलने से पहले उसे सरल करें।

## प्रोडक्शन में स्ट्रक्चर्ड आउटपुट की निगरानी कैसे करें?

चुपचाप रिपेयर करने वाला लूप ऐसी समस्या छिपा सकता है जो आपसे रोज़ टोकन ख़र्च करवाती है। हर कॉल साइट पर तीन संख्याएँ लॉग करें:

| मेट्रिक | यह क्या बताता है |
| --- | --- |
| पहली कोशिश में सफलता की दर | मॉडल और स्कीमा कितने मेल खाते हैं; गिरावट अक्सर प्रॉम्प्ट या मॉडल बदलने के बाद आती है |
| हर सफलता पर औसत कोशिशें | रिपेयर की टोकन लागत |
| आख़िरी विफलताएँ | वे इनपुट जिन्हें आपकी पाइपलाइन नहीं सँभाल पाती; इन्हें हाथ से देखें |

अगर पहली कोशिश की सफलता आपकी सामान्य दर से नीचे गिरे, तो और रीट्राई जोड़ने से पहले स्कीमा सरल करें या कोई दूसरा मॉडल आज़माएँ। फ़ेल हुए कच्चे जवाबों का एक सैंपल रखें, ताकि आप सुधारों को असली मामलों पर टेस्ट कर सकें।

## इसकी जगह टूल कब इस्तेमाल करें?

**आख़िरी जवाब** के लिए स्ट्रक्चर्ड आउटपुट इस्तेमाल करें: एक्सट्रैक्शन, वर्गीकरण, योजना। [टूल कॉलिंग](https://broadrouter.com/hi/blog/tool-calling-open-models/) तब इस्तेमाल करें जब मॉडल को आपके कोड से कुछ **करवाना** हो और फिर आगे बढ़ना हो। कई एजेंट दोनों इस्तेमाल करते हैं: लूप के दौरान टूल, और आख़िरी कदम के लिए स्कीमा। इमेज से JSON के उदाहरण के लिए [विज़न मॉडल से अरबी इनवॉइस पढ़ना](https://broadrouter.com/hi/guides/read-arabic-invoices-with-vision/) देखें।

## BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference, GLM 5.3 और Qwen3.8 27B के लिए स्ट्रक्चर्ड आउटपुट दिखाता है, मानक chat-completions फ़ॉर्मैट के पीछे, इसलिए ऊपर का कोड [OpenAI Python SDK](https://broadrouter.com/hi/guides/openai-python-sdk/) के साथ बिना बदलाव चलता है। Qwen3.8 27B इमेज भी लेता है, जो डॉक्यूमेंट एक्सट्रैक्शन के लिए ठीक है। BroadNet का डॉक्यूमेंटेशन DeepSeek V4.1 Flash या Gemma 4 VL 26B के लिए स्ट्रक्चर्ड आउटपुट नहीं बताता, इसलिए वहाँ वैलिडेशन के साथ सिर्फ़ प्रॉम्प्ट वाला तरीक़ा इस्तेमाल करें। प्रति टोकन कीमतों की तुलना [प्राइसिंग पेज](https://broadrouter.com/hi/pricing/) पर करें।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

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

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[स्ट्रक्चर्ड आउटपुट (structured output)](https://broadrouter.com/hi/glossary/structured-output/)

स्ट्रक्चर्ड आउटपुट LLM API का एक फ़ीचर है जो मॉडल के जवाब को डेवलपर के तय फ़ॉर्मैट, आम तौर पर JSON Schema, तक सीमित करता है, ताकि कोड उसे भरोसे से पार्स कर सके। यह JSON mode से सख़्त है, जो मान्य JSON की गारंटी देता है, लेकिन किसी ख़ास ढाँचे की नहीं।

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[JSON Schema (JSON स्कीमा)](https://broadrouter.com/hi/glossary/json-schema/)

JSON Schema, JSON में लिखी एक शब्दावली है, जो JSON डेटा की बनावट बताती और जाँचती है: टाइप, ज़रूरी फ़ील्ड, स्वीकार्य वैल्यू और नेस्टिंग। मौजूदा वर्ज़न 2020-12 है। LLM API इससे टूल पैरामीटर तय करते हैं, और वह सटीक आकार भी जिसका स्ट्रक्चर्ड आउटपुट को पालन करना है।

[JSON मोड (JSON mode)](https://broadrouter.com/hi/glossary/json-mode/)

JSON मोड, LLM API की एक सेटिंग है, OpenAI जैसे API में response\_format {"type": "json\_object"}, जो मॉडल के जवाब को वैलिड और पार्स होने लायक़ JSON बनाती है। JSON Schema वाले स्ट्रक्चर्ड आउटपुट के उलट, यह गारंटी नहीं देती कि ऑब्जेक्ट में कौन-सी keys, टाइप या वैल्यू होंगी।

[ओपन-वेट मॉडल (open-weight model)](https://broadrouter.com/hi/glossary/open-weight-model/)

ओपन-वेट मॉडल ऐसा मशीन लर्निंग मॉडल है जिसके ट्रेन किए weights सबके डाउनलोड करने और चलाने के लिए प्रकाशित होते हैं, आम तौर पर शर्तों वाले लाइसेंस के साथ। यह पूरी तरह ओपन-सोर्स AI से अलग है, जो ट्रेनिंग कोड और ट्रेनिंग डेटा की विस्तृत जानकारी भी जारी करता है, ताकि दूसरे मॉडल को समझ और दोबारा बना सकें।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[इनपुट और आउटपुट टोकन (input and output tokens)](https://broadrouter.com/hi/glossary/input-and-output-tokens/)

इनपुट टोकन वे टोकन हैं जिन्हें लैंग्वेज मॉडल किसी अनुरोध में पढ़ता है, जिनमें सिस्टम प्रॉम्प्ट, बातचीत का इतिहास, टूल डेफ़िनिशन और इमेज शामिल हैं। आउटपुट टोकन वे हैं जो वह जवाब में बनाता है, रीज़निंग समेत। LLM API आम तौर पर दोनों की कीमत अलग रखते हैं, और आउटपुट आम तौर पर महँगा होता है।

[विज़न-लैंग्वेज मॉडल (VLM)](https://broadrouter.com/hi/glossary/vision-language-model/)

विज़न-लैंग्वेज मॉडल (VLM) ऐसा मॉडल है जो इमेज और टेक्स्ट को साथ में इनपुट के रूप में लेकर टेक्स्ट बनाता है, ताकि वह तस्वीरों का वर्णन कर सके, उनके बारे में सवालों के जवाब दे सके और दस्तावेज़, चार्ट या स्क्रीनशॉट पढ़ सके। VLM को image-text-to-text या multimodal मॉडल भी कहते हैं।

## अक्सर पूछे जाने वाले सवाल

### JSON mode और स्ट्रक्चर्ड आउटपुट में क्या फ़र्क़ है?

JSON mode, यानी response\_format का type json\_object, सिर्फ़ यह वादा करता है कि जवाब JSON के रूप में पार्स होगा। स्ट्रक्चर्ड आउटपुट, यानी type json\_schema, आपके तय किए फ़ील्ड और टाइप का भी वादा करता है, जहाँ प्रोवाइडर इसे लागू करता है। OpenAI जहाँ संभव हो, JSON mode की जगह स्ट्रक्चर्ड आउटपुट की सलाह देता है।

### क्या ओपन मॉडल json\_schema वाला response\_format सपोर्ट करते हैं?

यह प्रोवाइडर पर निर्भर है। कुछ json\_schema स्वीकार करते हैं, कुछ सिर्फ़ json\_object, और कुछ इस फ़ील्ड को अनदेखा कर देते हैं। एक स्कीमा और ऐसे प्रॉम्प्ट के साथ टेस्ट अनुरोध भेजें जो मॉडल को एक अतिरिक्त फ़ील्ड जोड़ने के लिए उकसाए, फिर जवाब जाँचें।

### क्या स्ट्रक्चर्ड आउटपुट को फिर भी वैलिडेट करना ज़रूरी है?

हाँ। जवाब max\_tokens से कट सकते हैं, इनकार हो सकते हैं, और ऐसे बिज़नेस नियम तोड़ सकते हैं जिन्हें स्कीमा व्यक्त नहीं कर सकता, जैसे ऐसे टोटल जिनका जोड़ मिलना चाहिए।

### अमान्य JSON को कितनी बार रीट्राई करें?

वैलिडेशन एरर के साथ दो या तीन कोशिशें आम तौर पर काफ़ी हैं। उसके बाद इनपुट लॉग करें और उसे किसी फ़ॉलबैक, ज़्यादा ताक़तवर मॉडल या किसी इंसान के पास भेजें। असीमित लूप टोकन बर्बाद करते हैं।

### स्ट्रक्चर्ड आउटपुट इस्तेमाल करूँ या टूल कॉलिंग?

जब आपको आख़िरी जवाब एक तय ढाँचे में चाहिए, तो स्ट्रक्चर्ड आउटपुट। जब मॉडल को आपके कोड से कुछ करवाकर आगे बढ़ना है, तो टूल कॉलिंग।

## आगे पढ़ें

-   [LLM से अरबी टेक्स्ट classification: sentiment, intent, triage](https://broadrouter.com/hi/blog/arabic-text-classification-llm/)
-   [ओपन मॉडल के साथ टूल कॉलिंग: स्कीमा, पैरेलल कॉल, रीट्राई](https://broadrouter.com/hi/blog/tool-calling-open-models/)
-   [OpenAI-कम्पैटिबल API पर माइग्रेट करना: पूरी चेकलिस्ट](https://broadrouter.com/hi/blog/openai-compatible-api-migration-checklist/)
-   [सस्ते LLM पर n8n AI Agent: सेटअप, मॉडल का चुनाव और प्रति रन लागत](https://broadrouter.com/hi/blog/n8n-ai-agent-cheap-llm/)
-   [LLM का अमान्य JSON कैसे ठीक करें: कारण, रिपेयर, रीट्राई](https://broadrouter.com/hi/blog/fix-invalid-json-from-llm/)
-   [LLM से अरबी named entity extraction: JSON, तारीख़ें और जाँच](https://broadrouter.com/hi/blog/arabic-named-entity-extraction-llm/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: विज़न मॉडल से अरबी इनवॉइस और रसीदें पढ़ें](https://broadrouter.com/hi/guides/read-arabic-invoices-with-vision/)
-   [गाइड: रीज़निंग मॉडल ख़ाली जवाब क्यों लौटाता है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-structured-output-json-schema&utm_content=page-cta) ·

**स्रोत**

-   [OpenAI, Structured Outputs गाइड (2026-11-14 को देखा गया)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [OpenAI API रेफ़रंस, chat completion बनाना (response\_format)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Pydantic डॉक्यूमेंटेशन, JSON Schema और वैलिडेशन](https://docs.pydantic.dev/latest/concepts/json_schema/)
-   [BroadNet Inference API रेफ़रंस, मॉडल (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-structured-output-json-schema&utm_content=sources#models)
