---
title: "Невалидный JSON от LLM: причины, починка и повтор | BroadRouter"
description: "Почему LLM возвращают сломанный JSON (блоки кода, лишний текст, обрезка по max_tokens, висячие запятые) и проверенная функция на Python, чинящая только безопасное."
url: https://broadrouter.com/ru/blog/fix-invalid-json-from-llm/
lang: ru
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Переведено с английского с помощью ИИ. [Читать оригинал на английском](https://broadrouter.com/blog/fix-invalid-json-from-llm/) (обновлён 2026-11-16).

# Как исправить невалидный JSON от LLM: причины, починка, повтор

Команда BroadNet Inference · 7 мин чтения · Опубликовано 2026-11-15 · Обновлено 2026-11-16

Сначала проверьте finish\_reason: ответ, обрезанный по max\_tokens, безопасно не починить, поэтому увеличьте лимит и отправьте запрос заново. В остальных случаях уберите обёртку блока кода и текст вокруг, декодируйте первое JSON-значение и исправьте только однозначные ошибки вроде висячих запятых. Валидируйте по схеме, а при ошибке один-два раза отправьте её точный текст обратно. Структурированный вывод там, где он поддерживается, предотвращает большую часть этого.

## Главное

-   Чаще всего сломан не сам JSON, а обёртка: блок кода, фраза до или после, блок рассуждений. raw\_decode в Python читает первое значение и игнорирует остальное.
-   finish\_reason "length" означает, что JSON обрезан. Если закрыть скобки, он разберётся, но данные молча потеряются, поэтому лучше отправить запрос заново с бо́льшим лимитом.
-   Исправляйте только то, что имеет единственный смысл: висячие запятые, True/None в стиле Python и одинарные кавычки. Всё остальное отклоняйте и запрашивайте заново.
-   Модуль json в Python по умолчанию принимает 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 mode](https://broadrouter.com/ru/glossary/json-mode/) и `json_schema` разобран в статье [JSON mode или json\_schema](https://broadrouter.com/ru/blog/structured-output-json-schema/). Здесь речь о том, что делать с ответом, который вы фактически получили.

## Почему LLM возвращают невалидный JSON?

Модель пишет текст по одному токену. Если сервер не ограничивает декодирование, ничто не мешает ей добавить дружелюбную фразу или упереться в лимит. Типичные сбои:

| Что вы видите | Причина | Можно безопасно починить в коде? |
| --- | --- | --- |
| ` ```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) — нет | Да: смысл однозначен |
| `{'a': True, 'b': None}` | Синтаксис Python | Да: `ast.literal_eval` читает его безопасно |
| `NaN`, `Infinity` | Это не JSON; Python по умолчанию их принимает | Нет: отклонить |
| Валидный JSON, но не те типы или нет полей | Схема не обеспечивается | Нет: запросить заново с ошибкой |

Граница проходит по неоднозначности. Если модель могла иметь в виду ровно одно, исправьте это в коде и залогируйте, что исправили. Если пришлось бы угадывать, отклоните ответ.

## Почему не стоит чинить обрезанный JSON?

Потому что починенная версия выглядит правильной, но такой не является. Мы прогнали [json\_repair](https://github.com/mangiucugna/json_repair) 0.64.9, популярную библиотеку под лицензией MIT, на ответе, обрезанном посреди слова:

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

Она вернула валидный JSON с городом “Jed”. README библиотеки этого не скрывает: она “automatically completes missing values in JSON fields with reasonable defaults” (перевод: «автоматически дополняет недостающие значения в полях JSON разумными значениями по умолчанию»). Для чтения логов это полезно. Для данных, которые вы сохраняете или на основе которых действуете, это превращает видимый сбой в незаметный.

Проверяйте `finish_reason` до разбора. `"length"` означает, что ответ упёрся в [`max_tokens`](https://broadrouter.com/ru/glossary/max-tokens/). Тот же запрос с тем же лимитом сломается так же, поэтому удвойте лимит или просите меньше за один вызов. Модели с рассуждениями делают это чаще: [справочник API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-fix-invalid-json-from-llm&utm_content=body) BroadNet говорит, что DeepSeek V4.1 Flash, GLM 5.3 и Qwen3.8 27B рассуждают перед ответом, а рассуждения входят в `max_tokens`. При маленьком лимите ответ может прийти пустым. Оставляйте 1000 токенов и больше или ставьте `reasoning_effort` в `low`; цифры — в [статье о бюджете на рассуждения](https://broadrouter.com/ru/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.  **Обёртки блоков кода и блоки рассуждений** убираются двумя регулярными выражениями.
3.  **`raw_decode`** — ключевой инструмент. Документация Python говорит, что он декодирует документ “from a string that may have extraneous data at the end” (перевод: «из строки, в конце которой могут быть посторонние данные»), и возвращает позицию, где остановился. Начиная с первой `{` или `[`, он пропускает текст до объекта и игнорирует текст после. Если скобка в тексте не декодируется, пробуется следующая.
4.  **Сканирование скобок** проходит по тексту, отслеживая строки и экранирование. Незакрытые скобки означают, что ответ обрезан, даже если `finish_reason` об этом не сказал; в этом случае выбрасывается исключение. Запятые прямо перед `}` или `]` вне строк удаляются.
5.  **`ast.literal_eval`** читает вывод в стиле Python с одинарными кавычками, `True` и `None`. Он вычисляет только литералы и никогда не выполняет код. Результат затем должен сериализоваться как строгий JSON.
6.  **`NaN` и `Infinity`** вызывают исключение через `parse_constant`. Модуль `json` в Python по умолчанию их принимает; RFC 8259 говорит, что они “are not permitted” (перевод: «не допускаются»), а `JSON.parse` в JavaScript их отклоняет.

Мы прогнали функцию на 17 тестовых строках: чистый JSON, JSON в блоке кода, арабские ключи и значения в блоке кода, текст до и после, плейсхолдер `{name}` в тексте перед объектом, блок `<think>`, висячие запятые в объектах и массивах, запятые и скобки внутри строк, экранированные кавычки, путь Windows с обратным слешем в конце, литералы Python, `NaN`, пустой ответ, ответ, обрезанный с `finish_reason: "length"` и без него, и два объекта подряд. Всё вело себя так, как описано в таблице выше. Один тест поймал настоящую ошибку: ранняя версия переключала флаг экранирования до проверки закрывающей кавычки, и строка `"he said \"hi,]\""` теряла запятую. Тестируйте свой код починки на экранированных кавычках.

Два ограничения, о которых стоит знать. Если идут два объекта подряд, функция вернёт первый; если вам нужно несколько элементов, просите один JSON-массив. И вывод 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")
```

Правила этого цикла:

-   **Обрезан — отправьте те же сообщения с удвоенным лимитом.** Сообщение «пожалуйста, исправь» сделает промпт длиннее, а вывод не короче.
-   **Не JSON или не та структура — отправьте точный текст ошибки.** «amount: ‘1200’ is not of type ‘number’» даёт модели конкретное, что исправлять. Простой повтор часто воспроизводит ту же ошибку.
-   **Не больше трёх попыток.** Каждый повтор заново отправляет весь диалог как [входные токены](https://broadrouter.com/ru/glossary/input-and-output-tokens/). После трёх попыток залогируйте входные данные и отправьте их по другому маршруту.
-   **Логируйте список исправлений.** Если после правки промпта растёт число «removed code fence», значит, промпт стал хуже, даже если ничего не упало.

Мы прогнали этот цикл на локальном mock-сервере, который воспроизводил заранее заданные ответы. Ответ в блоке кода с висячей запятой и `"amount": "1200"` в виде строки был починен, не прошёл валидацию и был исправлен со второго вызова после отправки ошибки. Ответ, обрезанный с `finish_reason: "length"`, был отправлен заново с `max_tokens`, увеличенным с 1500 до 3000, и прошёл успешно. Mock-сервер каждый раз записывал запрос, что подтвердило число сообщений и лимит, отправленные циклом. Настоящая модель может сбоить иначе, поэтому прогоните цикл на 100 своих входных данных, прежде чем доверять цифрам.

## Делает ли структурированный вывод всё это ненужным?

Он убирает бо́льшую часть. Сервер, который ограничивает декодирование вашей схемой, не может выдать обёртку блока кода, висячую запятую или пропущенное поле. vLLM, распространённый сервер для открытых моделей, делает это с бэкендами xgrammar или guidance. Но два сбоя остаются и тогда: обрезка по `max_tokens` и отказы. OpenAI отмечает, что вывод в JSON mode валиден “except for in some edge cases” (перевод: «за исключением некоторых пограничных случаев») и что ваше приложение “must detect and handle” (перевод: «должно обнаруживать и обрабатывать») вывод, который не является полным объектом. Поэтому оставьте проверку `finish_reason` и валидатор даже с `json_schema`.

Что предотвращает каждый подход:

| Подход | Обёртка и лишний текст | Синтаксические ошибки | Не та структура | Обрезка |
| --- | --- | --- | --- | --- |
| Только промпт («ответь в JSON») | Реже | Реже | Реже | Нет |
| JSON mode (`json_object`) | Да | Да | Нет | Нет |
| Структурированный вывод (`json_schema`, обеспечивается) | Да | Да | Да | Нет |

Для JSON mode OpenAI также пишет, что вы “must always instruct the model to produce JSON” (перевод: «всегда должны указывать модели выдавать JSON») в одном из сообщений; иначе она может выдавать пробелы, пока не упрётся в лимит токенов. Другие OpenAI-совместимые серверы ведут себя по-разному, поэтому проверяйте режим на той модели, с которой выходите в продакшен. Тест — в [статье о структурированном выводе](https://broadrouter.com/ru/blog/structured-output-json-schema/).

Чтобы проверить ответ вручную, вставьте его в [валидатор JSON-вывода LLM](https://broadrouter.com/tools/llm-json-output-validator/) или постройте строгую схему по образцу объекта в [генераторе JSON Schema](https://broadrouter.com/tools/json-schema-generator/).

## Место BroadNet Inference

BroadRouter — сайт BroadNet. Справочник API BroadNet указывает структурированный вывод только для [GLM 5.3](https://broadrouter.com/ru/models/glm-5.3/) и [Qwen3.8 27B](https://broadrouter.com/ru/models/qwen3.8-27b/) и не называет параметр запроса, поэтому проверьте `json_schema` на модели, прежде чем на него полагаться. На [DeepSeek V4.1 Flash](https://broadrouter.com/ru/models/deepseek-v4.1-flash/) и [Gemma 4 VL 26B](https://broadrouter.com/ru/models/gemma-4-vl-26b/) используйте JSON по инструкции в промпте с функцией починки и валидатором выше. Три из четырёх моделей рассуждают перед ответом, так что закладывайте на это `max_tokens`. Для массового извлечения данных в [статье о пакетной обработке](https://broadrouter.com/ru/blog/llm-batch-processing-without-batch-api/) показано, как логировать `finish_reason` по каждому элементу. Промпты и ответы не хранятся после каждого запроса.

Бесплатные инструменты по теме (на английском)

-   [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/)

## Термины в этой статье

[JSON mode (режим JSON)](https://broadrouter.com/ru/glossary/json-mode/)

JSON mode — это настройка API языковой модели (в OpenAI-совместимых API — response\_format {"type": "json\_object"}), которая делает ответ модели валидным, разбираемым JSON. В отличие от structured outputs с JSON Schema, она не гарантирует, какие ключи, типы и значения будут в объекте.

[Вызов инструментов (tool calling)](https://broadrouter.com/ru/glossary/tool-calling/)

Вызов инструментов (function calling) — это функция LLM API, при которой модель возвращает структурированный запрос на выполнение функции, заданной разработчиком, с аргументами в JSON. Приложение выполняет функцию и отправляет результат обратно; сама модель код никогда не выполняет.

[JSON Schema (JSON-схема)](https://broadrouter.com/ru/glossary/json-schema/)

JSON Schema — это словарь, записанный на самом JSON, для описания и валидации структуры JSON-данных: типов, обязательных полей, допустимых значений и вложенности. Текущая версия — 2020-12. API языковых моделей используют его, чтобы задать параметры инструментов и точную форму структурированного вывода.

[Prefill и decode (префилл и декодирование)](https://broadrouter.com/ru/glossary/prefill-and-decode/)

Prefill и decode — это две фазы инференса LLM. На этапе prefill модель параллельно обрабатывает весь промпт и заполняет KV-кэш; на этапе decode она генерирует ответ по одному токену, повторно используя этот кэш. Prefill в основном определяет время до первого токена, decode — скорость вывода.

[Входные и выходные токены (input and output tokens)](https://broadrouter.com/ru/glossary/input-and-output-tokens/)

Входные токены — это токены, которые языковая модель читает в запросе: системный промпт, история диалога, описания инструментов и изображения. Выходные токены — это токены, которые она генерирует в ответ, включая рассуждения. LLM API обычно тарифицируют их по отдельности, и выход, как правило, дороже.

[Контекстное окно (context window)](https://broadrouter.com/ru/glossary/context-window/)

Контекстное окно — это максимальное число токенов, с которым языковая модель может работать в одном запросе. В него входят промпт, история диалога, описания инструментов, изображения и сгенерированный ответ, включая токены рассуждений. Всё, что не помещается, приходится обрезать, сжимать в краткое изложение или делить на несколько запросов.

[Токен (token)](https://broadrouter.com/ru/glossary/token/)

Токен — это единица текста, которую языковая модель читает и пишет: слово, часть слова, знак препинания или последовательность байтов, которую выдаёт токенизатор модели. LLM API считают, ограничивают и обычно тарифицируют использование в токенах.

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

vLLM — это библиотека с открытым кодом для инференса и сервинга LLM, изначально созданная в Sky Computing Lab Калифорнийского университета в Беркли. Она управляет памятью KV-кэша с помощью PagedAttention, непрерывно батчит входящие запросы, поддерживает многие форматы квантизации и предоставляет OpenAI-совместимый HTTP-сервер.

## Вопросы и ответы

### Почему LLM возвращает JSON внутри блока кода markdown?

Чат-модели обычно оформляют код для людей, а блок кода — это то, как его показывают чат-интерфейсы. Просите «только JSON, без блока кода», но всё равно убирайте обёртку в коде: инструкция снижает частоту, но не устраняет её.

### Как исправить JSONDecodeError на ответе LLM?

Сначала посмотрите на finish\_reason. Если там "length", ответ обрезан: увеличьте max\_tokens и отправьте запрос заново. Если нет, уберите обёртку блока кода и декодируйте первое JSON-значение через raw\_decode — он игнорирует текст после него. Исправьте висячие запятые и провалидируйте. Если не помогло, запросите ответ заново, приложив ошибку.

### Стоит ли использовать библиотеку для починки JSON?

Для логов и отладки — да. Для данных, на основе которых вы что-то делаете, — осторожно. Библиотеки вроде json\_repair достраивают недостающие значения значениями по умолчанию, так что обрезанный город "Jed" вернётся как валидный "Jed". Обрезанный вывод лучше отклонить и отправить запрос заново.

### Почему JSON от LLM обрезается?

Ответ упёрся в max\_tokens. У моделей с рассуждениями, таких как DeepSeek V4.1 Flash, GLM 5.3 и Qwen3.8 27B, рассуждения входят в этот лимит, и долгое размышление может оставить слишком мало места. Увеличьте лимит, поставьте reasoning\_effort low или просите меньше вывода за один вызов.

### Гарантирует ли JSON mode валидный JSON?

Почти. OpenAI пишет, что вывод в JSON mode — валидный JSON "except for in some edge cases" (перевод: «за исключением некоторых пограничных случаев»), например при достижении лимита токенов, и вашу схему он не обеспечивает. Структурированный вывод с json\_schema добавляет соответствие схеме там, где провайдер его обеспечивает. Валидируйте в любом случае.

### Какие модели BroadNet поддерживают структурированный вывод?

Справочник API BroadNet указывает структурированный вывод для GLM 5.3 и Qwen3.8 27B (проверено 15 ноября 2026 года). Для DeepSeek V4.1 Flash и Gemma 4 VL 26B он не указан, поэтому на них используйте JSON по инструкции в промпте с починкой и валидацией.

## Читайте также

-   [JSON mode или json\_schema: надёжный структурированный вывод LLM](https://broadrouter.com/ru/blog/structured-output-json-schema/)
-   [Вызов инструментов в открытых моделях: схемы, параллельность, повторы](https://broadrouter.com/ru/blog/tool-calling-open-models/)
-   [max\_tokens для моделей с рассуждениями: как рассчитать бюджет](https://broadrouter.com/ru/blog/reasoning-model-max-tokens-budget/)
-   [Классификация арабского текста с LLM: тональность, интенты, тикеты](https://broadrouter.com/ru/blog/arabic-text-classification-llm/)
-   [Пакетная обработка LLM без Batch API: возобновляемый раннер](https://broadrouter.com/ru/blog/llm-batch-processing-without-batch-api/)
-   [Перевод строк приложения на арабский через LLM: плейсхолдеры и плюралы](https://broadrouter.com/ru/blog/translate-app-strings-to-arabic-llm/)
-   [GPU-парк и подход к инференсу BroadNet — по описанию самой BroadNet](https://broadrouter.com/ru/blog/broadnet-gpu-fleet-and-serving/)
-   [Кэширование ответов LLM API: кэш точных совпадений на Python](https://broadrouter.com/ru/blog/cache-llm-responses-cut-cost/)
-   [Руководство: Почему рассуждающая модель возвращает пустой ответ](https://broadrouter.com/ru/guides/reasoning-tokens-empty-response/)
-   [Руководство: OpenAI Python SDK и BroadNet Inference](https://broadrouter.com/ru/guides/openai-python-sdk/)
-   [Руководство: Как читать арабские счета и чеки vision-моделью](https://broadrouter.com/ru/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=ru-blog-fix-invalid-json-from-llm&utm_content=page-cta) ·

**Источники**

-   [Справочник API BroadNet Inference: инструменты и структурированный вывод указаны только для 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=ru-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [OpenAI, руководство по Structured Outputs: JSON mode и соответствие схеме, указание модели выдавать JSON, пробелы до лимита токенов, неполный вывод, отказы (проверено 2026-11-15)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [IETF RFC 8259, формат обмена данными JSON: грамматика объектов, строки в двойных кавычках, 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)
-   [json\_repair на GitHub (MIT): чинит некорректный JSON и заполняет недостающие значения значениями по умолчанию (протестирована версия 0.64.9; проверено 2026-11-15)](https://github.com/mangiucugna/json_repair)
-   [Документация vLLM, структурированный вывод: json\_schema, regex, choice и grammar с бэкендами xgrammar или guidance (проверено 2026-11-15)](https://docs.vllm.ai/en/latest/features/structured_outputs.html)
