Слишком глубокая вложенность JSON: что значит «Maximum stack depth exceeded» и как исправить
Обновлено
Пятьсот двенадцать уровней скобок — это много. Глубже обычно не данные, а ошибка генератора. Предел глубины есть у каждого парсера, записан он где-нибудь или нет, и документ глубже предела падает, каким бы валидным он ни был.
Как выглядит слишком глубокий JSON и плоская версия
JSON, написанный руками, редко уходит глубже десяти уровней. Документы, которые упираются в предел, растут сами: ответ внутри ответа внутри ответа, дерево с циклом, сериализованное как есть, конверт вокруг данных на каждой повторной попытке. Такая форма добавляет уровень на каждую запись:
{"id": 1, "reply": {"id": 2, "reply": {"id": 3, "reply": {"id": 4, "reply": null}}}}Тысяча ответов — тысяча уровней. Те же данные плоским списком с идентификатором родителя остаются в двух уровнях, какой бы длинной ни была ветка:
[{"id": 1, "parent": null}, {"id": 2, "parent": 1}, {"id": 3, "parent": 2}, {"id": 4, "parent": 3}]Почему парсеры ограничивают вложенность (RFC 8259)
В грамматике предела нет: [[[[1]]]] валиден на любой глубине. RFC 8259, раздел 9 оставляет это парсеру: «An implementation may set limits on the maximum depth of nesting» — реализация вправе ограничить глубину вложенности. Поэтому каждый парсер выбирает свой предел, и числа ниже различаются в сотню раз.
Причина ограничения — стек вызовов. Многие парсеры обрабатывают массив, вызывая сами себя для каждого элемента, и каждый уровень стоит кадра стека; мегабайт символов [ — это миллион уровней. Без предела это падение процесса и простой способ положить любой эндпоинт, который разбирает присланное.
Пределы вложенности JSON в разных парсерах
Измерено 8 ноября 2026 года разбором вложенных массивов растущей глубины, [[…]]. «Уровни» считаются скобками: [[1]] — два уровня.
| Парсер | Предел по умолчанию | Сообщение за пределом |
|---|---|---|
| Chrome 156, Node 24–25 (V8) | Не достигнут: разобрано 1 000 000 уровней | Ошибки нет |
| Safari 27 (JavaScriptCore) | Не достигнут: разобрано 100 000 уровней | Ошибки нет |
| Python 3.9 | 994 уровня (предел рекурсии 1000) | RecursionError: maximum recursion depth exceeded while decoding a JSON array from a unicode string. Перевод: «превышена глубина рекурсии при разборе массива JSON» |
| Python 3.14 | Задаёт стек C: 6334 уровня в Alpine Linux | RecursionError: Stack overflow (used 992 kB) while decoding a JSON array from a unicode string. Перевод: «переполнение стека при разборе массива JSON» |
| Go 1.25–1.26 | 10 000 | invalid character '[' exceeded max depth. Перевод: «символ [ превысил максимальную глубину» |
| Go 1.27 | 10 000 | exceeded max depth. Перевод: «превышена максимальная глубина» |
| Java, Jackson 2.15 | 1000 | Depth (1001) exceeds the maximum allowed nesting depth (1000). Перевод: «глубина 1001 больше допустимой вложенности 1000» |
| Java, Jackson 2.23 | 1000 | Под таблицей |
| C#, System.Text.Json 10 | 64 | The maximum configured depth of 64 has been exceeded. Cannot read next JSON array.. Перевод: «превышена заданная максимальная глубина 64, следующий массив не прочитать» |
| C#, Newtonsoft.Json 13 | 64 | Начинается с «The reader» и называет MaxDepth of 64 |
| PHP 8.3 | depth 512, при котором проходит 511 вложенных массивов | Maximum stack depth exceeded. Перевод: «превышена максимальная глубина стека» (код ошибки 1) |
| Rust, serde_json 1.0 | 128 вложенных массивов уже не проходят | recursion limit exceeded at line 1 column 128. Перевод: «превышен предел рекурсии» |
| jq 1.7.1 | 256 | Exceeds depth limit for parsing at line 1, column 257. Перевод: «превышен предел глубины разбора» |
| MySQL 8.4 | 100 | The JSON document exceeds the maximum depth.. Перевод: «документ JSON глубже допустимого» |
| JSON Statham | 512 | Слишком глубокая вложенность, на 513-й открывающей скобке |
Document nesting depth (1001) exceeds the maximum allowed (1000, from `StreamReadConstraints.getMaxNestingDepth()`)Настоящая проблема — разброс. Документ в 100 уровней проходит Go, Jackson, PHP и Python и падает в C# с умолчанием 64; MySQL отвергает 101. Сервис, который принимает всё, что может разобрать, может выдать то, что сосед не прочтёт.
Как измерить глубину и задать предел
Сначала узнать, насколько документ глубок. Функции на JavaScript и Python ниже считают скобки вне строк и работают даже на тексте, который парсер отвергает; Go считает токены через json.Decoder. Поднимать предел стоит, только если глубина настоящая, а ввод доверенный. Все фрагменты запущены на 512 и 513 уровнях.
JavaScript: глубина текста JSON
function maxDepth(text) {
let depth = 0;
let deepest = 0;
let inString = false;
for (let i = 0; i < text.length; i++) {
const c = text[i];
if (inString) {
if (c === '\\') i++;
else if (c === '"') inString = false;
} else if (c === '"') inString = true;
else if (c === '{' || c === '[') deepest = Math.max(deepest, ++depth);
else if (c === '}' || c === ']') depth--;
}
return deepest;
}Python
def max_depth(text):
depth = deepest = 0
in_string = escaped = False
for c in text:
if in_string:
if escaped:
escaped = False
elif c == "\\":
escaped = True
elif c == '"':
in_string = False
elif c == '"':
in_string = True
elif c in "[{":
depth += 1
deepest = max(deepest, depth)
elif c in "]}":
depth -= 1
return deepestНастройки глубины в Python нет. В 3.9 более высокий sys.setrecursionlimit позволяет json.loads уйти глубже; в 3.14 предел задаёт стек C, и настройка за него не пускает. Сделать данные плоскими — способ, который работает везде.
Go
import (
"encoding/json"
"errors"
"io"
"strings"
)
func maxDepth(input string) (int, error) {
dec := json.NewDecoder(strings.NewReader(input))
depth, deepest := 0, 0
for {
tok, err := dec.Token()
if errors.Is(err, io.EOF) {
return deepest, nil
}
if err != nil {
return deepest, err
}
switch tok {
case json.Delim('{'), json.Delim('['):
depth++
deepest = max(deepest, depth)
case json.Delim('}'), json.Delim(']'):
depth--
}
}
}Предел 10 000 в encoding/json не настраивается; Go 1.27 применяет его и к Decoder.Token, поэтому на более глубоком документе функция вернёт 10 000 и ошибку.
Java (Jackson): задать предел явно
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.StreamReadConstraints;
import com.fasterxml.jackson.databind.ObjectMapper;
static ObjectMapper mapperWithDepth(int maxDepth) {
JsonFactory factory = JsonFactory.builder()
.streamReadConstraints(StreamReadConstraints.builder().maxNestingDepth(maxDepth).build())
.build();
return new ObjectMapper(factory);
}C# (System.Text.Json)
using System.Text.Json;
static JsonDocument ParseDeep(string text) =>
JsonDocument.Parse(text, new JsonDocumentOptions { MaxDepth = 512 });Тот же MaxDepth есть у JsonSerializerOptions и JsonReaderOptions; значение по умолчанию, 0, означает 64 (описание MaxDepth).
PHP
$data = json_decode($text, true, 513, JSON_THROW_ON_ERROR);PHP считает на один уровень больше, чем скобок: depth 512 отвергает 512 вложенных массивов, а принимает их 513.
Как держать JSON неглубоким
- Хранить деревья плоско. Список узлов с
parentили путь у каждого узла держат глубину постоянной, как бы ни росло дерево. - Искать циклы. Прямой цикл сериализаторы не пишут (
Converting circular structure to JSON,ValueError: Circular reference detected,json: unsupported value: encountered a cycle), но самописный обход и копирование с ограничением глубины выдают документ ровно той глубины, что их предел. - Оборачивать один раз. Промежуточный слой, который добавляет конверт на каждой повторной попытке или каждом переходе, делает плоские данные глубокими; сначала снять старый конверт, потом надевать новый.
- Договориться о пределе по всей цепочке. Решает самый строгий читатель: если один из потребителей на умолчаниях C#, настоящий предел всей цепочки — 64.
Проверить глубину в валидаторе
Попробовать: открыть пример со слишком глубокой вложенностью в валидаторе. JSON Statham принимает 512 уровней объектов и массивов вместе и сообщает о 513-й открывающей скобке с её строкой и колонкой. Для валидного документа валидатор показывает глубину в статистике, так что видно, далеко ли до чужого предела.
- Незакрытая скобка: когда скобки не сходятся вовсе.
- Просмотр JSON: исследовать глубокий документ деревом.
- Большие числа в JSON: ещё один предел, который у каждого парсера свой.
- Все ошибки JSON
Глубина вложенности JSON: частые вопросы
Какая максимальная глубина вложенности у JSON?
Стандарт её не задаёт: RFC 8259 оставляет выбор парсеру. Умолчания: 64 в C#, 100 в MySQL, 256 в jq 1.7, 512 в PHP и JSON Statham, 1000 в Jackson, 10 000 в Go; у V8 фиксированного предела нет.
Как поднять предел глубины?
C#: MaxDepth в настройках. Jackson: StreamReadConstraints с maxNestingDepth. PHP: третий аргумент json_decode. Предел Go в 10 000 не меняется, у Python он следует за стеком. Поднимать стоит только для доверенного ввода.
Что значит «Maximum stack depth exceeded» в PHP?
json_decode вышел за свой аргумент depth, по умолчанию 512. PHP считает на один уровень больше, чем скобок, поэтому 512 вложенным массивам нужен depth 513. Код ошибки — 1.
Какую глубину JSON принимает JSON Statham?
512 уровней объектов и массивов вместе. 513-я открывающая скобка получает «Слишком глубокая вложенность» с номером строки и колонки.