---
title: "LLM JSON 파싱 오류 해결: 원인, 복구, 재시도 | BroadRouter"
description: "LLM이 깨진 JSON(코드 펜스, 설명 문장, max_tokens 잘림, 후행 쉼표)을 반환하는 이유와, 안전한 것만 복구하고 나머지는 거부하는 검증된 Python 함수를 소개합니다."
url: https://broadrouter.com/ko/blog/fix-invalid-json-from-llm/
lang: ko
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 값을 디코딩한 뒤, 후행 쉼표처럼 의미가 하나뿐인 실수만 고치세요. 스키마로 검증하고, 실패하면 정확한 오류를 한두 번 돌려보내세요. 구조화된 출력을 지원하는 곳에서는 이런 문제 대부분을 예방할 수 있습니다.

## 핵심 요약

-   깨진 JSON의 대부분은 JSON 자체가 아니라 감싼 부분이 문제입니다. 코드 펜스, 앞뒤의 문장, 추론 블록 등입니다. Python의 raw\_decode는 첫 번째 값을 읽고 나머지는 무시합니다.
-   finish\_reason이 "length"이면 JSON이 잘렸다는 뜻입니다. 괄호를 닫아 주면 파싱은 되지만 데이터가 조용히 사라지므로, 대신 여유를 늘려 다시 보내세요.
-   의미가 하나뿐인 것만 고치세요. 후행 쉼표, 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/ko/glossary/json-mode/)와 `json_schema` 중 무엇을 고를지는 [JSON 모드와 json\_schema 비교](https://broadrouter.com/ko/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은 왜 복구하면 안 되나요?

복구된 결과가 맞아 보이지만 실제로는 틀리기 때문입니다. 널리 쓰이는 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/ko/glossary/max-tokens/)에 도달했다는 뜻입니다. 같은 요청을 같은 한도로 다시 보내면 똑같이 실패하므로, 한도를 두 배로 늘리거나 호출당 요청하는 양을 줄이세요. 추론 모델에서는 이런 일이 더 잦습니다. BroadNet의 [API 레퍼런스](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ko-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/ko/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`\*\*은 작은따옴표, `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"`가 있거나 없는 잘린 응답, 연속된 두 객체입니다. 모두 위 표대로 동작했습니다. 한 테스트에서는 실제 버그를 잡았습니다. 초기 버전이 닫는 따옴표를 확인하기 전에 이스케이프 플래그를 뒤집는 바람에 `"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/ko/glossary/input-and-output-tokens/)으로 다시 전송됩니다. 세 번 실패하면 입력을 로그에 남기고 다른 경로로 넘기세요.
-   **복구 목록을 로그에 남깁니다.** 프롬프트를 바꾼 뒤 “removed code fence” 횟수가 늘어난다면, 실패한 것은 없더라도 프롬프트가 나빠졌다는 신호입니다.

이 루프를 미리 작성한 응답을 재생하는 로컬 모의 서버에서 실행했습니다. 후행 쉼표가 있고 `"amount": "1200"`이 문자열인 펜스 응답은 복구된 뒤 검증에 실패했고, 오류를 돌려보낸 두 번째 호출에서 고쳐졌습니다. `finish_reason: "length"`로 잘린 응답은 `max_tokens`를 1,500에서 3,000으로 늘려 다시 보냈고 성공했습니다. 모의 서버는 매번 요청을 기록했으며, 루프가 보낸 메시지 수와 한도가 맞는지 확인했습니다. 실제 모델은 다르게 실패할 수 있으므로, 수치를 믿기 전에 직접 가진 입력 100개로 실행해 보세요.

## 구조화된 출력을 쓰면 이 작업이 필요 없나요?

대부분은 없어집니다. 디코딩을 스키마에 맞게 제약하는 서버는 펜스, 후행 쉼표, 누락된 필드를 출력할 수 없습니다. 널리 쓰이는 오픈 모델 서버인 vLLM은 xgrammar 또는 guidance 백엔드로 이를 수행합니다. 그래도 두 가지 실패는 남습니다. `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/ko/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/ko/models/glm-5.3/)과 [Qwen3.8 27B](https://broadrouter.com/ko/models/qwen3.8-27b/)에만 구조화된 출력을 표시하며 요청 파라미터 이름은 밝히지 않으므로, 의존하기 전에 해당 모델에서 `json_schema`를 테스트하세요. [DeepSeek V4.1 Flash](https://broadrouter.com/ko/models/deepseek-v4.1-flash/)와 [Gemma 4 VL 26B](https://broadrouter.com/ko/models/gemma-4-vl-26b/)에서는 프롬프트만으로 JSON을 요청하고 위의 복구 함수와 검증기를 함께 쓰세요. 네 모델 중 세 모델은 답하기 전에 추론하므로 그만큼 `max_tokens` 예산을 잡으세요. 대량 추출이라면 [배치 실행기 글](https://broadrouter.com/ko/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 모드(JSON mode)](https://broadrouter.com/ko/glossary/json-mode/)

JSON 모드는 OpenAI 방식 API의 response\_format {"type": "json\_object"} 같은 LLM API 설정으로, 모델의 응답을 파싱 가능한 유효한 JSON으로 만듭니다. JSON Schema를 쓰는 구조화된 출력과 달리, 객체에 어떤 키와 타입, 값이 들어갈지는 보장하지 않습니다.

[구조화된 출력(Structured output)](https://broadrouter.com/ko/glossary/structured-output/)

구조화된 출력(structured output)은 모델의 응답을 개발자가 지정한 형식, 주로 JSON Schema에 맞추도록 제한해 코드가 안정적으로 파싱할 수 있게 하는 LLM API 기능입니다. 유효한 JSON만 보장하고 특정 구조는 보장하지 않는 JSON 모드보다 더 엄격합니다.

[도구 호출(tool calling)](https://broadrouter.com/ko/glossary/tool-calling/)

도구 호출(tool calling)은 함수 호출(function calling)이라고도 하며, 모델이 개발자가 정의한 함수를 실행해 달라는 구조화된 요청을 JSON 인자와 함께 반환하는 LLM API 기능입니다. 함수는 애플리케이션이 실행하고 그 결과를 다시 보냅니다. 모델이 직접 코드를 실행하지는 않습니다.

[JSON Schema(JSON 스키마)](https://broadrouter.com/ko/glossary/json-schema/)

JSON Schema는 JSON으로 작성하는 어휘로, 타입, 필수 필드, 허용 값, 중첩 같은 JSON 데이터의 구조를 기술하고 검증합니다. 현재 버전은 2020-12입니다. LLM API는 이를 사용해 도구 파라미터와 구조화된 출력이 따라야 할 정확한 형태를 정의합니다.

[모델 라이선스(model license)](https://broadrouter.com/ko/glossary/model-license/)

모델 라이선스(model license)는 모델의 가중치, 코드, 출력을 사용하고 수정하고 공유할 수 있는 법적 조건입니다. 오픈 웨이트 모델은 Apache 2.0이나 MIT 같은 표준 소프트웨어 라이선스, 또는 대규모 상업 서비스 제한 같은 조건을 추가할 수 있는 자체 모델 라이선스를 씁니다.

[오픈 웨이트 모델(open-weight model)](https://broadrouter.com/ko/glossary/open-weight-model/)

오픈 웨이트 모델은 학습된 가중치를 공개해 누구나 내려받아 실행할 수 있게 한 머신러닝 모델로, 보통 조건이 붙은 라이선스로 배포됩니다. 학습 코드와 학습 데이터에 대한 상세한 정보까지 공개해 다른 사람이 모델을 연구하고 재현할 수 있게 하는 완전한 오픈 소스 AI와는 다릅니다.

[입력 토큰과 출력 토큰(input and output tokens)](https://broadrouter.com/ko/glossary/input-and-output-tokens/)

입력 토큰은 언어 모델이 요청에서 읽는 토큰으로, 시스템 프롬프트, 대화 기록, 도구 정의, 이미지가 포함됩니다. 출력 토큰은 모델이 응답으로 생성하는 토큰으로, 추론도 포함됩니다. LLM API는 보통 둘에 따로 가격을 매기며, 대개 출력이 더 비쌉니다.

[OpenAI 호환 API(OpenAI-compatible API)](https://broadrouter.com/ko/glossary/openai-compatible-api/)

OpenAI 호환 API는 POST /v1/chat/completions처럼 OpenAI API와 같은 요청 및 응답 형식을 받는 HTTP API입니다. 그래서 OpenAI SDK와 도구는 base URL, API 키, 모델 이름만 바꾸면 이 API를 그대로 사용할 수 있습니다.

## 자주 묻는 질문

### LLM이 JSON을 마크다운 코드 블록 안에 넣어서 반환하는 이유는 무엇인가요?

채팅 모델은 보통 사람이 읽도록 코드를 서식화하며, 채팅 화면에서 코드를 보여 주는 방식이 코드 펜스입니다. "코드 펜스 없이 JSON만"이라고 요청하되, 코드에서도 펜스를 반드시 제거하세요. 지시는 빈도를 줄일 뿐 없애지는 못합니다.

### LLM 출력에서 JSONDecodeError가 나면 어떻게 고치나요?

먼저 finish\_reason을 보세요. "length"라면 응답이 잘린 것이므로 max\_tokens를 늘려 다시 보내세요. 그렇지 않다면 코드 펜스를 제거하고, 뒤따르는 텍스트를 무시하는 raw\_decode로 첫 번째 JSON 값을 디코딩하세요. 후행 쉼표를 고친 뒤 검증하세요. 그래도 실패하면 오류를 담아 다시 요청하세요.

### JSON 복구 라이브러리를 써야 하나요?

로그와 디버깅용이라면 괜찮습니다. 실제로 사용할 데이터라면 조심하세요. json\_repair 같은 라이브러리는 누락된 값을 기본값으로 채우기 때문에, 잘린 도시 이름 "Jed"가 유효한 "Jed"로 돌아옵니다. 잘린 출력은 거부하고 다시 보내세요.

### LLM의 JSON 출력이 중간에 잘리는 이유는 무엇인가요?

응답이 max\_tokens에 도달했기 때문입니다. DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B 같은 추론 모델에서는 추론도 그 한도에 포함되므로, 사고가 길어지면 남는 공간이 부족해질 수 있습니다. 한도를 늘리거나, reasoning\_effort를 low로 설정하거나, 호출당 출력을 줄이세요.

### JSON 모드를 쓰면 유효한 JSON이 보장되나요?

거의 그렇습니다. OpenAI는 JSON 모드의 출력이 토큰 한도 도달 같은 "일부 예외적인 경우를 제외하고" 유효한 JSON이라고 설명하며, 스키마를 강제하지는 않습니다. json\_schema를 사용하는 구조화된 출력은 제공업체가 강제하는 경우 스키마 준수까지 더해 줍니다. 어느 쪽이든 검증하세요.

### BroadNet에서 구조화된 출력을 지원하는 모델은 무엇인가요?

BroadNet API 레퍼런스는 2026년 11월 15일 확인 기준 GLM 5.3과 Qwen3.8 27B에 구조화된 출력을 표시합니다. DeepSeek V4.1 Flash와 Gemma 4 VL 26B에는 표시하지 않으므로, 이 모델들에서는 프롬프트만으로 JSON을 요청하고 복구와 검증을 함께 쓰세요.

## 이어서 읽기

-   [JSON 모드 vs json\_schema: 믿고 쓸 수 있는 구조화된 출력](https://broadrouter.com/ko/blog/structured-output-json-schema/)
-   [오픈 모델 도구 호출: 스키마, 병렬 호출, 재시도](https://broadrouter.com/ko/blog/tool-calling-open-models/)
-   [추론 모델의 max\_tokens 설정: 토큰 예산을 정하는 방법](https://broadrouter.com/ko/blog/reasoning-model-max-tokens-budget/)
-   [LLM으로 아랍어 텍스트 분류하기: 감성 분석, 의도, 티켓 분류](https://broadrouter.com/ko/blog/arabic-text-classification-llm/)
-   [Batch API 없이 LLM 일괄 처리하기: 재개 가능한 실행기](https://broadrouter.com/ko/blog/llm-batch-processing-without-batch-api/)
-   [LLM으로 앱 문자열 아랍어 번역하기: 플레이스홀더와 복수형](https://broadrouter.com/ko/blog/translate-app-strings-to-arabic-llm/)
-   [BroadNet의 GPU 하드웨어와 서빙 방식: BroadNet이 밝힌 내용](https://broadrouter.com/ko/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API 응답 캐싱으로 비용 줄이기: Python 정확 일치 캐시](https://broadrouter.com/ko/blog/cache-llm-responses-cut-cost/)
-   [가이드: 추론 모델이 빈 답변을 반환하는 이유](https://broadrouter.com/ko/guides/reasoning-tokens-empty-response/)
-   [가이드: BroadNet Inference에서 OpenAI Python SDK 사용하기](https://broadrouter.com/ko/guides/openai-python-sdk/)
-   [가이드: 비전 모델로 아랍어 인보이스와 영수증 읽기](https://broadrouter.com/ko/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=ko-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=ko-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [OpenAI Structured Outputs 가이드: JSON 모드와 스키마 준수 비교, 모델에 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)
-   [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)
