# Слишком глубокая вложенность JSON: что значит «Maximum stack depth exceeded» и как исправить

> Узнать предел вложенности JSON в каждом парсере, от 64 в C# до 10 000 в Go, что значит «Maximum stack depth exceeded» и как это исправить.

- Адрес: https://jsonstatham.dev/ru/errors/too-deep/
- Язык: Русский (ru)
- Английская версия: https://jsonstatham.dev/errors/too-deep.md
- Обновлено: 2026-11-08

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

## Как выглядит слишком глубокий JSON и плоская версия

JSON, написанный руками, редко уходит глубже десяти уровней. Документы, которые упираются в предел, растут сами: ответ внутри ответа внутри ответа, дерево с циклом, сериализованное как есть, конверт вокруг данных на каждой повторной попытке. Такая форма добавляет уровень на каждую запись:

```json
{"id": 1, "reply": {"id": 2, "reply": {"id": 3, "reply": {"id": 4, "reply": null}}}}
```

Тысяча ответов — тысяча уровней. Те же данные плоским списком с идентификатором родителя остаются в двух уровнях, какой бы длинной ни была ветка:

```json
[{"id": 1, "parent": null}, {"id": 2, "parent": 1}, {"id": 3, "parent": 2}, {"id": 4, "parent": 3}]
```

## Почему парсеры ограничивают вложенность (RFC 8259)

В грамматике предела нет: `[[[[1]]]]` валиден на любой глубине. [RFC 8259, раздел 9](https://www.rfc-editor.org/rfc/rfc8259#section-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-й открывающей скобке |

```text
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

```js
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

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

```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): задать предел явно

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

```csharp
using System.Text.Json;

static JsonDocument ParseDeep(string text) =>
    JsonDocument.Parse(text, new JsonDocumentOptions { MaxDepth = 512 });
```

Тот же `MaxDepth` есть у `JsonSerializerOptions` и `JsonReaderOptions`; значение по умолчанию, 0, означает 64 ([описание MaxDepth](https://learn.microsoft.com/ru-ru/dotnet/api/system.text.json.jsondocumentoptions.maxdepth)).

### PHP

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

## Проверить глубину в валидаторе

[Попробовать: открыть пример со слишком глубокой вложенностью в валидаторе](https://jsonstatham.dev/ru/validator/?sample=too_deep). JSON Statham принимает 512 уровней объектов и массивов вместе и сообщает о 513-й открывающей скобке с её строкой и колонкой. Для валидного документа валидатор показывает глубину в статистике, так что видно, далеко ли до чужого предела.

- [Незакрытая скобка](https://jsonstatham.dev/ru/errors/unclosed-bracket/): когда скобки не сходятся вовсе.
- [Просмотр JSON](https://jsonstatham.dev/ru/viewer/): исследовать глубокий документ деревом.
- [Большие числа в JSON](https://jsonstatham.dev/ru/guides/json-big-numbers/): ещё один предел, который у каждого парсера свой.
- [Все ошибки JSON](https://jsonstatham.dev/ru/errors/)

## Глубина вложенности 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-я открывающая скобка получает «Слишком глубокая вложенность» с номером строки и колонки.
