---
title: "LLM の不正な JSON を直す：原因・修復・リトライ | BroadRouter"
description: "LLM が壊れた JSON を返す理由（コードフェンス、前後の文章、max_tokens での途切れ、末尾のカンマ）と、安全に直せるものだけを直し残りは拒否する、テスト済みの Python 関数を紹介します。"
url: https://broadrouter.com/ja/blog/fix-invalid-json-from-llm/
lang: ja
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

このページは英語の原文を AI の支援を受けて翻訳したものです。[英語の原文を読む](https://broadrouter.com/blog/fix-invalid-json-from-llm/)（2026-11-16 更新）。

# LLM が返す不正な JSON の直し方：原因・修復・リトライ

BroadNet Inference チーム · 約 7 分で読めます · 公開日 2026-11-15 · 更新日 2026-11-16

まず finish\_reason を確認します。max\_tokens で途切れた返答は安全に直せないので、上限を上げて再送します。それ以外はコードフェンスと前後の文章を除き、最初の JSON 値をデコードし、末尾のカンマのような曖昧さのない誤りだけを直します。スキーマで検証し、失敗したら正確なエラーを返して 1〜2 回再依頼します。

## 要点

-   壊れた JSON の多くは、JSON 自体の誤りではなく包み方の問題です。コードフェンス、前後の 1 文、推論ブロックなどです。Python の raw\_decode は最初の値だけを読み、残りを無視します。
-   finish\_reason が "length" なら JSON は途中で切れています。括弧を閉じればパースは通りますが、データが黙って失われるので、余裕を増やして再送してください。
-   直すのは意味が 1 つに決まるものだけです。末尾のカンマ、Python 風の True/None、シングルクォートです。それ以外は拒否して再依頼します。
-   Python の json モジュールはデフォルトで NaN と Infinity を受け付けますが、RFC 8259 は認めていません。拒否しないと、下流の別のパーサーで失敗します。
-   BroadNet Inference で構造化出力がドキュメントに記載されているのは GLM 5.3 と Qwen3.8 27B だけです。ほかのモデルでは、プロンプトのみの JSON にこの修復と検証を組み合わせてください。

**このページの内容**

1.  LLM が不正な JSON を返すのはなぜですか？
2.  途中で切れた JSON を修復しないのはなぜですか？
3.  安全なケースだけを直す修復関数
4.  修復に失敗したら、どうリトライすべきですか？
5.  構造化出力を使えば、これは不要になりますか？
6.  BroadNet Inference が向いている場面

モデルの返答に `json.loads()` を呼ぶと、`JSONDecodeError: Expecting value: line 1 column 1` が出る。あるいはパースは通ったのに、数値のはずのフィールドが文字列になっている。この記事では、原因をそれぞれに対して安全にできることで分類し、曖昧さのないケースだけを直すテスト済みの Python 関数と、リトライしても無駄なときを見分けるリトライループを紹介します。

[JSON モード](https://broadrouter.com/ja/glossary/json-mode/)と `json_schema` の選び方は、[JSON モードと json\_schema](https://broadrouter.com/ja/blog/structured-output-json-schema/) で解説しています。この記事で扱うのは、実際に受け取った返答をどう処理するかです。

## LLM が不正な JSON を返すのはなぜですか？

モデルはテキストを 1 トークンずつ書きます。サーバーがデコードを制約しない限り、親切な一文を添えたり、途中で余地がなくなったりするのを止めるものはありません。よくある失敗は次のとおりです。

| 見えるもの | 原因 | コードで安全に直せるか |
| --- | --- | --- |
| ` ```json ` … ` ``` ` でオブジェクトを囲む | チャット向けの整形の癖 | 可：フェンスを除去 |
| 前に「Here is the JSON:」、後ろに「Let me know…」 | 同じ癖 | 可：最初の値だけを読む |
| オブジェクトの前に `<think>...</think>` | 一部のサーバーで推論テキストが content フィールドに入る | 可：ブロックを削除 |
| 文字列の途中で終わり、括弧が開いたまま | `max_tokens` に到達 | 不可：余裕を増やして再送 |
| content が空 | 推論が予算をすべて使った | 不可：余裕を増やして再送 |
| `{"a": 1,}` | 末尾のカンマ。JavaScript は許すが、[RFC 8259](https://www.rfc-editor.org/rfc/rfc8259) は許さない | 可：意味は 1 つ |
| `{'a': True, 'b': None}` | Python の構文 | 可：`ast.literal_eval` で安全に読める |
| `NaN`、`Infinity` | JSON ではない。Python はデフォルトで受け付ける | 不可：拒否 |
| 正しい JSON だが型が違う、フィールドが欠けている | スキーマが強制されていない | 不可：エラーを添えて再依頼 |

境界線は曖昧さです。モデルの意図が 1 つしかあり得ないなら、コードで直し、直したことをログに残します。推測が必要なら、その返答は拒否します。

## 途中で切れた JSON を修復しないのはなぜですか？

修復した結果が正しそうに見えて、実は間違っているからです。人気のある MIT ライセンスのライブラリ [json\_repair](https://github.com/mangiucugna/json_repair) 0.64.9 で、単語の途中で切れた返答を処理してみました。

```text
'{"name": "Omar", "city": "Jed'  ->  {'name': 'Omar', 'city': 'Jed'}
```

返ってきたのは、都市が “Jed” の正しい JSON でした。README もこの点を隠しておらず、“automatically completes missing values in JSON fields with reasonable defaults”（訳：JSON フィールドの欠けた値を妥当なデフォルト値で自動的に補う）と書いています。ログを読むには便利です。しかし保存したり処理に使ったりするデータでは、目に見える失敗を気づかれない失敗に変えてしまいます。

パースする前に `finish_reason` を確認してください。`"length"` は返答が [`max_tokens`](https://broadrouter.com/ja/glossary/max-tokens/) に達したことを意味します。同じ上限で同じリクエストを再送しても同じように失敗するので、上限を 2 倍にするか、1 回あたりの出力を減らします。推論モデルではこれがより起こりやすくなります。BroadNet の [API リファレンス](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ja-blog-fix-invalid-json-from-llm&utm_content=body)によると、DeepSeek V4.1 Flash、GLM 5.3、Qwen3.8 27B は回答前に推論し、推論は `max_tokens` に含まれます。上限が小さいと、回答が空で返ることがあります。1,000 トークン以上を空けるか、`reasoning_effort` を `low` にしてください。具体的な数字は[推論の予算についての記事](https://broadrouter.com/ja/blog/reasoning-model-max-tokens-budget/)にあります。

## 安全なケースだけを直す修復関数

標準ライブラリだけを使います。パースした値と、行った修復のリストを返すので、件数を集計できます。

```python
import ast, json, re

class Truncated(Exception): pass
class NotJSON(Exception): pass

FENCE = re.compile(r"```(?:json|JSON)?\s*\n(.*?)```", re.S)
THINK = re.compile(r"<think>.*?</think>", re.S)

def _reject_constant(name):                 # NaN, Infinity: Python accepts them, JSON does not
    raise NotJSON(f"non-standard constant {name}")

_decoder = json.JSONDecoder(parse_constant=_reject_constant)

def _first_value(s):
    """Decode the first JSON object or array in s, ignoring prose before and after it."""
    for i, ch in enumerate(s):
        if ch in "{[":
            try:
                return _decoder.raw_decode(s, i)[0]
            except json.JSONDecodeError:
                continue                    # a stray brace in prose; try the next one
    raise NotJSON("no JSON object or array found")

def _scan(s):
    """Drop commas before } or ] outside strings; report brackets left open."""
    out, stack, in_str, esc = [], [], False, False
    for i, ch in enumerate(s):
        if in_str:
            if esc:
                esc = False
            elif ch == "\\":
                esc = True
            elif ch == '"':
                in_str = False
        elif ch == '"':
            in_str = True
        elif ch in "{[":
            stack.append(ch)
        elif ch in "}]" and stack:
            stack.pop()
        elif ch == ",":
            rest = s[i + 1:].lstrip()
            if rest[:1] in ("}", "]"):
                continue                    # trailing comma: skip it
        out.append(ch)
    return "".join(out), len(stack) + (1 if in_str else 0)

def _python_literal(s):
    """Output in Python syntax: single quotes, True/False/None, trailing commas."""
    start = min((i for i in (s.find("{"), s.find("[")) if i >= 0), default=-1)
    end = max(s.rfind("}"), s.rfind("]"))
    if start < 0 or end <= start:
        raise NotJSON("no braces")
    value = ast.literal_eval(s[start:end + 1])       # literals only; never runs code
    if not isinstance(value, (dict, list)):
        raise NotJSON("not an object or array")
    json.dumps(value, allow_nan=False)               # must round-trip as strict JSON
    return value

def parse_llm_json(content, finish_reason=None):
    """Return (value, repairs). Raises Truncated or NotJSON."""
    if finish_reason == "length":
        raise Truncated("hit max_tokens; raise the limit or shorten the output")
    if not content or not content.strip():
        raise NotJSON("empty content (reasoning may have used the whole budget)")
    repairs = []
    s = content.strip().lstrip("\ufeff")
    if THINK.search(s):
        s = THINK.sub("", s).strip(); repairs.append("removed <think> block")
    m = FENCE.search(s)
    if m:
        s = m.group(1).strip(); repairs.append("removed code fence")
    try:
        value = _decoder.decode(s)
        return value, repairs
    except json.JSONDecodeError:
        pass
    try:
        value = _first_value(s); repairs.append("ignored text around JSON")
        return value, repairs
    except NotJSON:
        pass
    fixed, open_count = _scan(s)
    if open_count:
        raise NotJSON(f"incomplete JSON, {open_count} bracket(s) or string left open: treat as truncated")
    if fixed != s:
        try:
            value = _first_value(fixed); repairs.append("removed trailing commas")
            return value, repairs
        except NotJSON:
            pass
    try:
        value = _python_literal(s); repairs.append("parsed Python-style literal")
        return value, repairs
    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError, NotJSON) as e:
        raise NotJSON(f"unrepairable: {e}") from None
```

各ステップの働きは次のとおりです。

1.  **途中で切れた返答と空の返答**は、パースの前に例外を出すので、データになることはありません。
2.  **フェンスと推論ブロック**は 2 つの正規表現で除去します。
3.  **`raw_decode`** が鍵になるツールです。Python のドキュメントによると、これは “from a string that may have extraneous data at the end”（訳：末尾に余分なデータがあるかもしれない文字列から）ドキュメントをデコードし、止まった位置を返します。最初の `{` か `[` から始めるので、オブジェクトの前の文章を飛ばし、後ろの文章を無視します。文章中の括弧でデコードに失敗したら、次の括弧を試します。
4.  **括弧のスキャン**は、文字列とエスケープを追跡しながらテキストを走査します。括弧が開いたままなら、`finish_reason` がそう言っていなくても返答は途中で切れているので、例外を出します。文字列の外で `}` や `]` の直前にあるカンマは削除します。
5.  **`ast.literal_eval`** は、シングルクォート、`True`、`None` を使う Python 風の出力を読みます。評価するのはリテラルだけで、コードは決して実行しません。その結果は厳密な JSON としてシリアライズできる必要があります。
6.  **`NaN` と `Infinity`** は `parse_constant` を通じて例外になります。Python の `json` はデフォルトでこれらを受け付けますが、RFC 8259 は “are not permitted”（訳：許可されない）としており、JavaScript の `JSON.parse` も拒否します。

17 個のテスト文字列で動かしました。きれいな JSON、フェンス付きの JSON、フェンス内のアラビア語のキーと値、前後の文章、オブジェクトの前の文章にある `{name}` プレースホルダー、`<think>` ブロック、オブジェクトと配列の末尾のカンマ、文字列内のカンマと括弧、エスケープされた引用符、バックスラッシュで終わる Windows のパス、Python リテラル、`NaN`、空の返答、`finish_reason: "length"` があるものとないものの途切れた返答、そして 2 つ連続したオブジェクトです。どれも上の表のとおりに動きました。1 つのテストで実際のバグが見つかりました。初期のバージョンは、閉じ引用符を確認する前にエスケープフラグを反転させていたため、`"he said \"hi,]\""` のカンマが消えていました。自分の修復コードも、エスケープされた引用符でテストしてください。

知っておくべき制限が 2 つあります。オブジェクトが 2 つ続く場合は最初のものを返します。複数の項目が必要なら、JSON 配列を 1 つ返すよう依頼してください。また、シングルクォートの Python 出力で文字列内にダブルクォートを含むものは、括弧のスキャンが誤読して拒否されることがあります。拒否は安全な失敗です。

## 修復に失敗したら、どうリトライすべきですか？

修復は形式を扱います。検証は内容を扱います。正しいフィールド、正しい型、妥当な値です。次のループは `jsonschema` パッケージで検証し、原因に応じてリトライの方法を選びます。

```python
import json, os
from jsonschema import Draft202012Validator
from openai import OpenAI
from llm_json import parse_llm_json, Truncated, NotJSON

client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
SCHEMA = {"type": "object", "additionalProperties": False,
          "required": ["name", "city", "amount"],
          "properties": {"name": {"type": "string", "minLength": 1},
                         "city": {"type": ["string", "null"]},
                         "amount": {"type": "number", "minimum": 0}}}
validator = Draft202012Validator(SCHEMA)

def extract(text, model="broadnet/qwen3.8-27b", max_tokens=1500, attempts=3, log=print):
    messages = [{"role": "system", "content": "Extract name, city and amount. Reply with one JSON object only, no code fence. "
                                              "Schema: " + json.dumps(SCHEMA)},
                {"role": "user", "content": text}]
    for attempt in range(1, attempts + 1):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens,
                                           reasoning_effort="low", temperature=0)
        c = r.choices[0]
        try:
            value, repairs = parse_llm_json(c.message.content, c.finish_reason)
            errors = [f"{'/'.join(map(str, e.path)) or '(root)'}: {e.message}" for e in validator.iter_errors(value)]
            if not errors:
                log({"attempt": attempt, "repairs": repairs, "ok": True})
                return value
            problem = "The JSON does not match the schema: " + "; ".join(errors)
        except Truncated:
            log({"attempt": attempt, "ok": False, "why": "truncated"})
            max_tokens *= 2                 # same prompt, more room; a re-ask would be cut off too
            continue
        except NotJSON as e:
            problem = f"That reply was not valid JSON ({e})."
        log({"attempt": attempt, "ok": False, "why": problem})
        messages += [{"role": "assistant", "content": c.message.content or ""},
                     {"role": "user", "content": problem + " Return the corrected JSON object only."}]
    raise RuntimeError(f"no valid JSON after {attempts} attempts")
```

このループのルールは次のとおりです。

-   **途中で切れた場合：同じメッセージを、上限を 2 倍にして再送します。**「直してください」というメッセージを足すと、プロンプトが長くなるだけで、出力は短くなりません。
-   **JSON でない、または形が違う場合：正確なエラーを返します。**「amount: ‘1200’ is not of type ‘number’」なら、モデルは何を直せばよいかが具体的にわかります。何も添えずにリトライすると、同じ間違いを繰り返しがちです。
-   \*\*試行は 3 回までにします。\*\*リトライのたびに会話全体が[入力トークン](https://broadrouter.com/ja/glossary/input-and-output-tokens/)として再送されます。3 回を超えたら、入力をログに残して別の処理に回します。
-   \*\*修復のリストをログに残します。\*\*プロンプトを変えた後に「removed code fence」の件数が増えていれば、何も失敗していなくても、プロンプトが悪くなったことがわかります。

このループを、台本どおりの返答を再生するローカルのモックサーバーで動かしました。フェンス付きで末尾にカンマがあり、`"amount": "1200"` が文字列になっている返答は、修復されて検証に失敗し、エラーを返した 2 回目の呼び出しで直りました。`finish_reason: "length"` で途切れた返答は、`max_tokens` を 1,500 から 3,000 に上げて再送され、成功しました。モックは毎回リクエストを記録し、ループが送ったメッセージ数と上限を確認できました。実際のモデルは違う形で失敗することもあるので、数字を信用する前に、自分の入力 100 件で試してください。

## 構造化出力を使えば、これは不要になりますか？

ほとんどは不要になります。デコードをスキーマに制約するサーバーは、フェンスも末尾のカンマも欠けたフィールドも出力できません。オープンモデルでよく使われるサーバーの vLLM は、xgrammar または guidance バックエンドでこれを実現しています。それでも 2 つの失敗は残ります。`max_tokens` での途切れと、拒否です。OpenAI は、JSON モードの出力は “except for in some edge cases”（訳：一部の例外的なケースを除いて）正しいと述べ、完全なオブジェクトでない出力はアプリケーションが “must detect and handle”（訳：検出して処理しなければならない）としています。ですから `json_schema` を使う場合でも、`finish_reason` の確認と検証は残してください。

それぞれの方法で防げるもの：

| 方法 | フェンスと文章 | 構文エラー | 形の誤り | 途切れ |
| --- | --- | --- | --- | --- |
| プロンプトのみ（「JSON で返答して」） | 減る | 減る | 減る | 防げない |
| JSON モード（`json_object`） | 防げる | 防げる | 防げない | 防げない |
| 構造化出力（`json_schema`、強制あり） | 防げる | 防げる | 防げる | 防げない |

JSON モードについて OpenAI は、メッセージの中で “must always instruct the model to produce JSON”（訳：必ず JSON を出力するようモデルに指示しなければならない）とも述べています。そうしないと、トークン上限に達するまで空白を出し続けることがあります。ほかの OpenAI 互換サーバーは対応がまちまちなので、リリースするモデルでこのモードをテストしてください。テストの方法は[構造化出力の記事](https://broadrouter.com/ja/blog/structured-output-json-schema/)にあります。

返答を手で確認するなら、[LLM JSON 出力バリデーター](https://broadrouter.com/tools/llm-json-output-validator/)に貼り付けるか、[JSON スキーマジェネレーター](https://broadrouter.com/tools/json-schema-generator/)でサンプルオブジェクトから厳密なスキーマを作ってください。

## BroadNet Inference が向いている場面

BroadRouter は BroadNet のサイトです。BroadNet の API リファレンスで構造化出力が記載されているのは [GLM 5.3](https://broadrouter.com/ja/models/glm-5.3/) と [Qwen3.8 27B](https://broadrouter.com/ja/models/qwen3.8-27b/) だけで、リクエストのパラメーター名も書かれていません。頼る前に、そのモデルで `json_schema` をテストしてください。[DeepSeek V4.1 Flash](https://broadrouter.com/ja/models/deepseek-v4.1-flash/) と [Gemma 4 VL 26B](https://broadrouter.com/ja/models/gemma-4-vl-26b/) では、プロンプトのみの JSON に上の修復関数と検証を組み合わせてください。4 モデルのうち 3 つは回答前に推論するので、その分の `max_tokens` を確保してください。大量の抽出には、項目ごとに `finish_reason` を記録する方法を示した[バッチ実行の記事](https://broadrouter.com/ja/blog/llm-batch-processing-without-batch-api/)が参考になります。プロンプトと返答は、各リクエストの後に保持されません。

関連する無料ツール（英語）

-   [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 Outputs）](https://broadrouter.com/ja/glossary/structured-output/)

構造化出力とは、モデルの回答を開発者が指定した形式（通常は JSON Schema）に制約し、コードで確実に解析できるようにする LLM API の機能です。有効な JSON であることだけを保証し、特定の形までは保証しない JSON モードより厳格です。

[トークン（token）](https://broadrouter.com/ja/glossary/token/)

トークンとは、言語モデルが読み書きするテキストの単位です。モデルのトークナイザーが作る単語、単語の一部、句読点、バイト列のいずれかにあたります。LLM API は利用量をトークンで数え、上限を設け、通常はトークン単位で課金します。

[プリフィルとデコード（prefill and decode）](https://broadrouter.com/ja/glossary/prefill-and-decode/)

プリフィルとデコードは LLM 推論の 2 つのフェーズです。プリフィルではプロンプト全体を並列に処理して KV キャッシュを埋め、デコードではそのキャッシュを使って 1 トークンずつ生成します。前者は主に初回トークンまでの時間、後者は出力速度を決めます。

[JSON Schema（JSON スキーマ）](https://broadrouter.com/ja/glossary/json-schema/)

JSON Schema とは、JSON データの構造（型、必須フィールド、許可される値、入れ子）を記述・検証するための、JSON で書かれた語彙です。現行バージョンは 2020-12 です。LLM API はツールのパラメーターや、構造化出力が従うべき正確な形の定義に使います。

[ツール呼び出し（Function Calling、tool calling）](https://broadrouter.com/ja/glossary/tool-calling/)

ツール呼び出し（Function Calling とも呼ばれます）とは、開発者が定義した関数の実行を求める構造化されたリクエストを、モデルが JSON の引数付きで返す LLM API の機能です。関数を実行して結果を返すのはアプリケーションで、モデル自身がコードを実行することはありません。

[OpenAI 互換 API（OpenAI-compatible API）](https://broadrouter.com/ja/glossary/openai-compatible-api/)

OpenAI 互換 API とは、POST /v1/chat/completions など OpenAI API と同じリクエスト形式とレスポンス形式を受け付ける HTTP API です。OpenAI の SDK やツールは、ベース URL、API キー、モデル名を変えるだけで利用できます。

[vLLM](https://broadrouter.com/ja/glossary/vllm/)

vLLM とは、LLM の推論とサービングのためのオープンソースライブラリで、UC バークレーの Sky Computing Lab で開発が始まりました。PagedAttention で KV キャッシュのメモリを管理し、リクエストを連続的にバッチ処理し、多くの量子化形式に対応し、OpenAI 互換の HTTP サーバーを提供します。

[オープンウェイトモデル（open-weight model）](https://broadrouter.com/ja/glossary/open-weight-model/)

オープンウェイトモデルとは、学習済みの重みが公開され、誰でもダウンロードして実行できるモデルで、通常は条件付きのライセンスで提供されます。学習コードや学習データの詳細も公開し、他者が検証・再現できる完全なオープンソース AI とは別物です。

## よくある質問

### LLM が JSON を markdown のコードブロックに入れて返すのはなぜですか？

チャットモデルは普通、人が読むためにコードを整形します。コードフェンスはチャット画面でコードを表示する方法です。「JSON のみ、コードフェンスなし」と頼むのは有効ですが、それでもコード側でフェンスを除去してください。指示で頻度は下がりますが、なくなりはしません。

### LLM の出力で JSONDecodeError が出たらどう直せばいいですか？

まず finish\_reason を見ます。"length" なら返答は途中で切れているので、max\_tokens を上げて再送します。そうでなければコードフェンスを除き、raw\_decode で最初の JSON 値をデコードします。raw\_decode はその後ろのテキストを無視します。末尾のカンマを直してから検証し、それでも失敗したらエラーを添えて再依頼します。

### JSON 修復ライブラリは使うべきですか？

ログやデバッグなら使って構いません。処理に使うデータでは注意が必要です。json\_repair のようなライブラリは欠けた値をデフォルト値で補うので、途中で切れた都市名 "Jed" が正しい "Jed" として返ってきます。途中で切れた出力は拒否して再送してください。

### LLM の JSON 出力が途中で切れるのはなぜですか？

返答が max\_tokens に達したからです。DeepSeek V4.1 Flash、GLM 5.3、Qwen3.8 27B のような推論モデルでは推論もこの上限に含まれるので、長く考えると回答の余地が足りなくなります。上限を上げるか、reasoning\_effort を low にするか、1 回の呼び出しで求める出力を減らしてください。

### JSON モードなら正しい JSON が保証されますか？

ほぼ保証されます。OpenAI によると、JSON モードの出力は正しい JSON ですが “except for in some edge cases”（訳：一部の例外的なケースを除く）で、トークン上限に達した場合などが該当します。また、スキーマは強制されません。json\_schema による構造化出力は、プロバイダーが強制する場合にスキーマ準拠も加わります。どちらでも検証してください。

### BroadNet のどのモデルが構造化出力に対応していますか？

2026 年 11 月 15 日に確認したところ、BroadNet の API リファレンスで構造化出力が記載されているのは GLM 5.3 と Qwen3.8 27B です。DeepSeek V4.1 Flash と Gemma 4 VL 26B には記載がないので、これらではプロンプトのみの JSON に修復と検証を組み合わせてください。

## 続けて読む

-   [JSON モードと json\_schema：壊れない構造化出力の作り方](https://broadrouter.com/ja/blog/structured-output-json-schema/)
-   [オープンモデルのツール呼び出し：スキーマ、並列呼び出し、リトライ](https://broadrouter.com/ja/blog/tool-calling-open-models/)
-   [推論モデルの max\_tokens の決め方：予算を見積もる方法](https://broadrouter.com/ja/blog/reasoning-model-max-tokens-budget/)
-   [LLM によるアラビア語テキスト分類：感情、意図、振り分け](https://broadrouter.com/ja/blog/arabic-text-classification-llm/)
-   [Batch API なしで LLM を一括処理する：再開できるランナー](https://broadrouter.com/ja/blog/llm-batch-processing-without-batch-api/)
-   [LLM でアプリの文字列をアラビア語に翻訳：プレースホルダーと複数形](https://broadrouter.com/ja/blog/translate-app-strings-to-arabic-llm/)
-   [BroadNet の GPU ハードウェアとサービング方式（BroadNet の説明による）](https://broadrouter.com/ja/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API のレスポンスをキャッシュしてコスト削減：Python の完全一致キャッシュ](https://broadrouter.com/ja/blog/cache-llm-responses-cut-cost/)
-   [ガイド：推論モデルが空の回答を返す理由](https://broadrouter.com/ja/guides/reasoning-tokens-empty-response/)
-   [ガイド：OpenAI Python SDK を BroadNet Inference で使う](https://broadrouter.com/ja/guides/openai-python-sdk/)
-   [ガイド：ビジョンモデルでアラビア語の請求書とレシートを読み取る](https://broadrouter.com/ja/guides/read-arabic-invoices-with-vision/)

実際のワークロードで試してください。新規アカウントには US$5 の初回クレジットがあり、Gemma、文字起こし に使えます。DeepSeek、GLM、Qwen3.8 はチャージが必要です。

[始める](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=ja-blog-fix-invalid-json-from-llm&utm_content=page-cta) ·

**出典**

-   [BroadNet Inference API リファレンス：ツールと構造化出力が記載されているのは GLM 5.3 と Qwen3.8 27B のみ。DeepSeek V4.1 Flash、GLM 5.3、Qwen3.8 27B は推論し、推論は max\_tokens に含まれる（2026-11-16 確認）（英語）](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ja-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [OpenAI 構造化出力ガイド：JSON モードとスキーマ準拠、JSON を出力するよう指示すること、トークン上限までの空白、不完全な出力、拒否（2026-11-15 確認）](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [IETF RFC 8259「The JSON Data Interchange Format」：オブジェクトの文法、ダブルクォートの文字列、Infinity と NaN は不可（2026-11-15 確認）](https://www.rfc-editor.org/rfc/rfc8259)
-   [Python ドキュメント json モジュール：JSONDecoder.raw\_decode、NaN と Infinity はデフォルトで受理、parse\_constant（2026-11-15 確認）](https://docs.python.org/3/library/json.html)
-   [GitHub の json\_repair（MIT）：不正な JSON を修復し、欠けた値をデフォルト値で補う（バージョン 0.64.9 でテスト、2026-11-15 確認）](https://github.com/mangiucugna/json_repair)
-   [vLLM ドキュメント 構造化出力：xgrammar または guidance バックエンドによる json\_schema、regex、choice、grammar（2026-11-15 確認）](https://docs.vllm.ai/en/latest/features/structured_outputs.html)
