Как подключить Gemini 4 Neon API: ID модели, уровни рассуждений и проверка первого запроса

Вызов gemini-4-neon из платного проекта Gemini API: выбор между high и xhigh, учёт токенов рассуждений и кэшированных токенов, ошибки, которые отличаются от Carbon.

Четырёхпозиционный поворотный переключатель на деревянном основании; четвёртая позиция отмечена оранжевым, провод ведёт к выключенной стеклянной трубчатой лампе.

Чтобы вызвать Gemini 4 Neon, отправьте model: "gemini-4-neon" из проекта Gemini API на платном уровне: бесплатного уровня у Neon нет. По умолчанию модель рассуждает на уровне high, также принимает low, medium и xhigh, а входные данные, рассуждения и ответ делят одно окно в 1 048 576 токенов. В руководстве Google по Neon новый код начинают с Interactions API, но generateContent тоже работает. Запрос можно считать успешным, только если interaction имеет статус completed (или candidate завершился с STOP), в ответе есть видимый текст, а запись об использовании показывает, за что вам выставят счёт, включая токены рассуждений.

Google выпустила gemini-4-neon в общий доступ (GA) 18 ноября 2026 года. Руководство сверено с документацией Google 19 ноября 2026 года. Здесь разобрано то, что относится именно к Neon. Настройка проекта, API-ключи и оплата такие же, как у другой платной модели Gemini 4, поэтому подробно они описаны один раз в нашем руководстве по настройке Gemini 4 Carbon API, а здесь приведены кратко.

У статьи два ограничения:

  • Neon недоступна в Ofox. Мы проверили список моделей Ofox (GET https://api.ofox.io/v1/models) 19 ноября 2026 года: в нём есть google/gemini-4-hydrogen и google/gemini-4-argon, но нет Neon, а https://ofox.io/models/google/gemini-4-neon вернул 404. Во всех примерах ниже используются нативный эндпоинт Google и API-ключ Google. Этот блог публикует Ofox.
  • Мы не делали реальный вызов Neon. Для этой статьи у нас не было ключа Google. Тела запросов сверены с опубликованным контрактом Google (руководство по Neon, справочники Interactions и generateContent, документация по рассуждениям, кэшированию и длинной генерации). Скрипт проверки ответов протестирован офлайн на 15 синтетических ответах. Это подтверждает логику разбора, но не подтверждает аутентификацию, задержку или качество ответов.

Gemini 4 Neon API: основные параметры

Все значения ниже взяты из руководства Google What’s new in Gemini 4 Neon, страницы цен и карточки модели Neon (все на английском), проверено 19 ноября 2026 года.

ПараметрЗначение для Neon
ID моделиgemini-4-neon (без суффикса -preview)
ДоступТолько платный уровень Gemini API; также Google AI Studio с планами Google AI Pro и Ultra
APIInteractions API (используется в быстром старте Google) и generateContent
Уровни рассужденийlow, medium, high (по умолчанию), xhigh; minimal отклоняется
Контекст1 048 576 токенов, общие для входа, рассуждений и ответа
Синхронный вывод65 536 токенов по умолчанию и максимум на один hop (этап генерации), со стримингом и без
Более длинный выводФоновое выполнение или продолжение на стороне клиента, до 1M минус входные токены
Стандартная цена (USD за 1M токенов)Вход $3,00, кэшированный вход $0,15, вывод с учётом рассуждений $15,00
КэшированиеТолько неявное, от 4 096 токенов промпта; явный cachedContents не поддерживается
Сэмплированиеtemperature, top_p, top_k игнорируются, если значения в допустимом диапазоне; вне диапазона — ошибка 400
Дата среза знанийМарт 2026 года (карточка модели)

Вводной цены у Neon нет, в отличие от Carbon, у которой она действует до 30 ноября. Стоимость задачи на разных уровнях рассуждений разобрана в нашем материале о ценах Gemini 4 Neon.

Что меняется по сравнению с запросами к Carbon и Hydrogen

Google пишет, что переход на Neon с другой модели Gemini 4 «не требует изменений схемы запроса». Поля остаются прежними, меняются их значения и ограничения вокруг них. Если у вас уже есть рабочий код по нашим руководствам для Carbon или Hydrogen, учтите следующие отличия.

ОбластьCarbonHydrogenNeon
ID моделиgemini-4-carbongemini-4-hydrogengemini-4-neon
Бесплатный уровеньНетЕстьНет
Уровень рассуждений по умолчаниюmediumhighhigh
xhighНе поддерживаетсяПоддерживаетсяПоддерживается
Hop без стриминга32 768 токенов на hop в «сыром» REST65 53665 536
Параметры сэмплированияИгнорируютсяВ диапазоне игнорируются, вне диапазона 400В диапазоне игнорируются, вне диапазона 400
Стандартная цена (вход / вывод)$2 / $10 до 30 ноября, затем $4 / $20$1,50 / $7,50$3 / $15, фиксированная

Источники: руководства «What’s new» для Carbon, Hydrogen и Neon и страница Choosing a model (на английском). Сравнение hop в 32 768 и 65 536 токенов приведено в руководстве Google по Hydrogen.

Из этого следуют три практических вывода:

  1. При переходе с Carbon растут расходы на вызов по умолчанию. У Carbon по умолчанию medium, у Neon — high. Код, который никогда не задавал thinking_level, на Neon будет рассуждать больше, хотя вы ничего не меняли. Задавайте уровень явно, чтобы это поведение было видно на код-ревью.
  2. При переходе с Hydrogen сбой может быть связан с ключом, а не с запросом. Интеграция с Hydrogen может работать в проекте на бесплатном уровне. С тем же ключом до Neon не достучаться. Прежде чем отлаживать тело запроса, проверьте, к какому проекту относится ключ.
  3. Код, написанный для Neon, может не работать с Carbon. xhigh допустим для Neon и Hydrogen, но не для Carbon и Argon. Если вы распределяете шаги между моделями, сделайте уровень рассуждений частью маршрута, а не глобальной константой. Когда каждая из моделей оправдывает свою цену, разобрано в сравнении Neon и Carbon.

Шаг 1. Убедитесь, что ключ относится к платному проекту

Для Neon должны совпасть четыре условия: аккаунт Google с доступом к Gemini API, проект в Google AI Studio, API-ключ, принадлежащий этому проекту, и активная оплата платного уровня в том же проекте. В руководстве Google по оплате переход с бесплатного уровня на платный описан как привязка платёжного аккаунта к проекту, а на странице Projects видно, на каком уровне находится каждый проект. План Google AI Pro или Ultra даёт доступ к Neon в AI Studio, но не считайте его доказательством того, что проект вашего API-ключа на платном уровне. Проверьте уровень проекта на этой странице.

Пошаговая инструкция (импорт проекта Cloud, типы ключей и ограничения, предоплата и постоплата) есть в первом разделе руководства по Carbon, и для Neon она подходит без изменений. Первоисточники Google — руководство по API-ключам и руководство по оплате (на английском).

Храните ключ в переменной окружения и проверяйте, что он загружен, не выводя его значение:

export GEMINI_API_KEY="..."   # задайте в shell или менеджере секретов, никогда не коммитьте
python3 -c 'import os; print("Key configured:", bool(os.environ.get("GEMINI_API_KEY")))'

True означает лишь, что значение существует. Есть ли у проекта доступ к Neon, покажет первый запрос.

Шаг 2. Отправьте первый запрос через Interactions API

Быстрый старт Google для Neon использует Interactions API, поэтому новый код начинайте с него. Установите актуальный SDK (google-genai, импортируется как from google import genai; не старый пакет google-generativeai):

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade google-genai

Сохраните это как neon_first_call.py:

import json
import os
from pathlib import Path
from google import genai

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])

interaction = client.interactions.create(
    model="gemini-4-neon",
    input="List exactly three checks for confirming a new API integration works.",
    store=False,
    generation_config={
        "thinking_level": "low",
        "max_output_tokens": 65536,
    },
)

Path("neon-response.json").write_text(
    json.dumps(interaction.model_dump(mode="json"), indent=2), encoding="utf-8"
)
print("Status:", interaction.status)
print("Usage:", interaction.usage)
print(interaction.output_text)

Три параметра в этом запросе выбраны намеренно:

  • thinking_level: "low" делает проверку доступа дешёвой. Иначе Neon рассуждала бы на уровне high. Используйте low, чтобы проверить маршрут, а затем задайте уровень, который нужен вашей реальной нагрузке (шаг 5).
  • max_output_tokens: 65536 — документированное значение Neon по умолчанию и предел на один hop. Это потолок для рассуждений и видимого ответа вместе, а не прогноз счёта. Google не советует переносить низкие лимиты вроде 8 192 из старых приложений; если хотите тратить меньше, снизьте уровень рассуждений.
  • store=False исключает этот разовый вызов из хранения. Оставьте хранение включённым (по умолчанию), если будете использовать background=True или previous_interaction_id: обоим нужны сохранённые interaction. На платном уровне Google хранит сохранённые interaction 55 дней.

Тот же запрос через REST — так удобно видеть, что именно уходит по сети:

curl --silent --show-error --max-time 900 \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-4-neon",
    "input": "List exactly three checks for confirming a new API integration works.",
    "store": false,
    "generation_config": {
      "thinking_level": "low",
      "max_output_tokens": 65536
    }
  }' \
  --output neon-response.json

В Interactions API имена полей внутри generation_config записываются в snake_case и в Python, и в JavaScript, и в REST. output_text — вспомогательное свойство SDK; в «сыром» ответе REST текст находится в элементах steps с типом model_output, внутри записей content с типом text.

--max-time в 900 секунд соответствует совету Google в руководстве по миграции: для сложных промптов закладывать не меньше 15 минут. Простой промпт на уровне low должен вернуться гораздо быстрее. Если клиент отвалился по тайм-ауту, сервер всё равно мог обработать запрос (и выставить за него счёт), поэтому не запускайте автоматический повтор, пока не проверите.

Шаг 3. Или используйте generateContent, если ваш клиент уже на нём

generateContent по-прежнему поддерживается для Neon. Если приложение уже разбирает candidates, возможно, достаточно поменять строку модели и настройки рассуждений. Обратите внимание на другой регистр: REST для generateContent использует camelCase.

curl --silent --show-error --max-time 900 \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-neon:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "List exactly three checks for confirming a new API integration works."}]}],
    "generationConfig": {
      "thinkingConfig": {"thinkingLevel": "low"},
      "maxOutputTokens": 65536
    }
  }' \
  --output neon-response.json

Вариант для Python SDK:

from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model="gemini-4-neon",
    contents="List exactly three checks for confirming a new API integration works.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="low"),
        max_output_tokens=65536,
    ),
)
print(response.text)
print("Thinking tokens:", response.usage_metadata.thoughts_token_count)

В обоих вариантах значения уровня — строки в нижнем регистре ("low", "xhigh"), как в руководстве Google по рассуждениям (на английском). Не смешивайте два API: generation_config.thinking_level относится к телу запроса Interactions, а generationConfig.thinkingConfig.thinkingLevel — к телу generateContent. Если после копирования кода из одного API в другой вы получили 400, сначала проверьте структуру полей. Также уберите старый thinkingBudget (thinking_budget): в Gemini 4 он устарел, а вместе с уровнем рассуждений приводит к ошибке 400.

Выбирайте один API для каждого пути в коде. Interactions API даёт состояние на стороне сервера (previous_interaction_id) и фоновое выполнение. С generateContent историю вы ведёте сами и должны отправлять предыдущие ходы модели обратно без изменений, включая их подписи рассуждений (thought signatures).

Шаг 4. Проверьте статус, текст и использование, прежде чем доверять вызову

HTTP 200 недостаточно. Interaction может вернуться со статусом, отличным от completed, а candidate в generateContent может завершиться с MAX_TOKENS, израсходовав весь бюджет на рассуждения. В обоих случаях видимого текста может не быть совсем. В руководстве Google по длинной генерации (на английском) для каждого статуса Interactions указано действие:

СтатусЧто означаетЧто делать
queued, in_progressЕщё выполняется (фоновые вызовы)Опрашивайте interactions.get с тем же id
completedЗавершеноСоедините текст из model_output и прочитайте usage
requires_actionМодель запросила вызов инструментаВыполните инструмент и отправьте результат с этим id
requires_continuationHop на переднем плане упёрся в предел 65 536, но бюджет ещё осталсяSDK по умолчанию продолжает сам; в REST отправьте следующий hop с previous_interaction_id и continuation_token
incompleteИзрасходован весь max_output_tokens; текст может быть пустымПродолжите или отправьте заново с бо́льшим max_output_tokens
failedСервер не смог завершитьПовторите один раз; если снова ошибка, сохраните id для поддержки
cancelledВы отменили вызовПрочитайте usage, чтобы увидеть, что выставлено в счёт

В generateContent этому соответствуют значения finishReason: STOP — успех, MAX_TOKENS — достигнут предел, CONTINUATION — нужен ещё один hop (последние версии SDK продолжают автоматически).

Этот скрипт проверяет сохранённый ответ любого из двух API. Он не обращается к сети и никогда не повторяет запросы:

import json
import sys
from pathlib import Path

PENDING = {"queued", "in_progress"}


def check_interaction(p):
    status = p.get("status")
    if status in PENDING:
        raise ValueError(f"Still {status}: poll interactions.get with this id later")
    if status != "completed":
        raise ValueError(f"Interaction status is {status}, not completed (see the status table)")
    text = "".join(
        c.get("text", "")
        for s in p.get("steps", [])
        if s.get("type") == "model_output"
        for c in s.get("content", [])
        if c.get("type") == "text"
    )
    u = p.get("usage") or {}
    usage = {
        "input": u.get("total_input_tokens"),
        "cached_input": u.get("total_cached_tokens"),
        "output": u.get("total_output_tokens"),
        "thinking": u.get("total_thought_tokens"),
        "tool_use": u.get("total_tool_use_tokens"),
        "total": u.get("total_tokens"),
    }
    return text, usage


def check_generate_content(p):
    cands = p.get("candidates") or []
    if not cands:
        reason = (p.get("promptFeedback") or {}).get("blockReason")
        raise ValueError(f"No candidates (prompt block reason: {reason})")
    c = cands[0]
    reason = c.get("finishReason")
    if reason != "STOP":
        raise ValueError(f"finishReason is {reason}, not STOP")
    text = "".join(
        part.get("text", "")
        for part in (c.get("content") or {}).get("parts", [])
        if not part.get("thought")
    )
    u = p.get("usageMetadata") or {}
    usage = {
        "input": u.get("promptTokenCount"),
        "cached_input": u.get("cachedContentTokenCount", 0),
        "output": u.get("candidatesTokenCount"),
        "thinking": u.get("thoughtsTokenCount"),
        "tool_use": u.get("toolUsePromptTokenCount", 0),
        "total": u.get("totalTokenCount"),
    }
    return text, usage


def check(payload):
    if "error" in payload:
        raise ValueError("API error: " + json.dumps(payload["error"]))
    if "candidates" in payload or "promptFeedback" in payload:
        text, usage = check_generate_content(payload)
    elif "status" in payload or "steps" in payload:
        text, usage = check_interaction(payload)
    else:
        raise ValueError("Unrecognised response shape")
    if not text.strip():
        raise ValueError("Completed, but no visible text")
    return text, usage


if __name__ == "__main__":
    path = sys.argv[1] if len(sys.argv) > 1 else "neon-response.json"
    payload = json.loads(Path(path).read_text(encoding="utf-8"))
    try:
        text, usage = check(payload)
    except ValueError as exc:
        raise SystemExit(str(exc))
    print("Usage:", json.dumps(usage))
    print(text)

Запустите python3 check_neon.py neon-response.json. При успехе скрипт выводит строку с нормализованными данными об использовании и видимый ответ. Затем прочитайте сам ответ: в нём должны быть три уместные проверки, а не отказ и не оборванное предложение.

Что мы протестировали. Мы запустили скрипт проверки ровно в том виде, в каком он приведён выше, на 15 вручную написанных фикстурах: завершённый interaction, где текст разбит на два шага model_output и есть шаг рассуждений; тот же interaction после прохода через модель Interaction SDK google-genai и model_dump(mode="json"), как его сохраняет шаг 2; interaction со статусами in_progress, incomplete, requires_action, requires_continuation, failed и завершённый, но пустой; тело ошибки API; ответы generateContent, завершившиеся с STOP (с частью рассуждений, которую нужно исключить), MAX_TOKENS, CONTINUATION, MALFORMED_FUNCTION_CALL, а также заблокированный промпт и ответ, состоящий только из рассуждений. Три корректных успешных ответа прошли проверку, остальные двенадцать завершились с ожидаемым сообщением. Фикстуры следуют документированным именам полей; это не записанный вывод Neon.

Какие поля использования важны для Neon

В записи об использовании видны оба рычага стоимости Neon: рассуждения и попадания в кэш.

ЗначениеInteractions usagegenerateContent usageMetadata
Входные токеныtotal_input_tokenspromptTokenCount
Вход из кэшаtotal_cached_tokenscachedContentTokenCount
Видимый ответtotal_output_tokenscandidatesTokenCount
Рассужденияtotal_thought_tokensthoughtsTokenCount
Токены промпта для инструментовtotal_tool_use_tokenstoolUsePromptTokenCount
Всегоtotal_tokenstotalTokenCount

Имена полей взяты из справочников Google по API Interactions и generateContent (на английском). Пример из справочника Google (для более ранней модели, не Neon) показывает, что рассуждения учитываются отдельно от видимого ответа: 49 токенов рассуждений рядом с 23 токенами ответа на ответ в одно предложение. В Neon рассуждения оплачиваются по ставке вывода $15,00. Google считает каждый токен, который обрабатывает модель, включая рассуждения, а при grounding — ещё и внутренние системные инструкции и объявления функций. Поэтому на уровнях high или xhigh даже короткий видимый ответ может обойтись дорого. Записывайте thinking рядом с output для каждого вызова: если счёт выглядит странно, начинать стоит с этой пары.

Шаг 5. Выбирайте уровень рассуждений под задачу

Руководство Google описывает четыре уровня примерно так (в пересказе):

УровеньОписание GoogleТипичное применение
lowМеньше всего токенов, минимальная задержкаБыстрый чат, высокопроизводительная обработка, дешёвые проверки доступа
mediumМеньший расход токенов, более быстрые ответыИнтерактивное программирование, прототипирование UI, вызовы инструментов, чувствительные к задержке
high (по умолчанию)Баланс интеллекта и скоростиБольшинство сложных задач программирования, агентное выполнение, мультимодальная работа со знаниями
xhighБольше всего токенов, самые глубокие рассужденияСложная многошаговая инженерия, аналитические и научные задачи, где high не хватает

Метод, который рекомендует Google: оцените задачу на всех четырёх уровнях с высоким max_output_tokens, чтобы лимит не обрезал ответы, а затем используйте самый низкий уровень, который проходит вашу планку качества. Запрос с xhigh:

interaction = client.interactions.create(
    model="gemini-4-neon",
    input="Audit this retry queue for race conditions and rewrite the lock logic.",
    generation_config={"thinking_level": "xhigh"},
)

Две оговорки, специфичные для Neon:

  • xhigh и предел 65 536 влияют друг на друга. Предел распространяется на рассуждения и ответ вместе. Руководство Google по рассуждениям предупреждает, что на простых промптах, например при извлечении текста или JSON, xhigh может рассуждать избыточно и исчерпать max_output_tokens. Если вы видите MAX_TOKENS или interaction со статусом incomplete и почти без видимого текста, сначала посмотрите на задачу. Для простой задачи снизьте уровень. Для действительно сложной оставьте уровень и дайте модели больше места с помощью фонового выполнения и большего max_output_tokens (см. раздел о фоновом выполнении ниже). Не уменьшайте max_output_tokens ради экономии: как отмечает Google, это обрезает ответ, а за уже выполненные рассуждения вы всё равно платите.
  • Заявления Google о стоимости измерены на конкретных уровнях. В анонсе Neon Google утверждает, что на уровне по умолчанию high Neon сочетает высокий балл в Artificial Analysis Intelligence Index со стоимостью задачи на 32% ниже, чем у Carbon, а наивысший балл интеллекта Neon получает на xhigh. Google привязывает эти 32% к AA Intelligence Index, но не уточняет, с каким уровнем рассуждений Carbon, с каким ценовым периодом Carbon и с каким срезом данных AA шло сравнение; по данным AA, которые мы прочитали 19 ноября 2026 года, 32% не воспроизводятся — сравнение есть в нашем разборе цен Neon. Это результаты бенчмарков, опубликованные Google, а не прогноз для вашей нагрузки. Измеряйте собственную задачу по полям использования, описанным выше.

previous_interaction_id переносит только историю диалога. Он не переносит generation_config, tools или system_instruction, поэтому следующий ход без thinking_level вернётся к значению Neon по умолчанию — high. Передавайте уровень заново на каждом ходе.

Используйте неявное кэширование вместо cachedContents

Neon поддерживает только неявное кэширование. Если вы переносите код, который создаёт кэши через caches.create или отправляет cached_content, удалите эти поля. В руководстве Google по кэшированию сказано, что явное кэширование не поддерживается ни в Interactions API, ни для моделей Gemini 4.

Неявное кэширование срабатывает автоматически для промптов от 4 096 токенов. Попадание оплачивается по $0,15 за 1M входных токенов вместо $3,00, то есть со скидкой 95%. Добиться попадания принудительно нельзя, но руководство Google по кэшированию (на английском) называет два способа повысить шансы:

  • Размещайте крупный общий контент (системные инструкции, карту репозитория, справочный документ) в начале промпта, а вопрос конкретного запроса — в конце.
  • Отправляйте запросы с одинаковым префиксом близко друг к другу по времени.

Для многоходовых чатов и агентных циклов Google добавляет правило для Gemini 4: предыдущий запрос кэшируется целиком, только если новый запрос добавляет не меньше 2 050 токенов (учитываются ответ модели, рассуждения и результаты функций). При меньшем приросте последние 2 050 токенов предыдущего запроса обрабатываются заново по стандартной ставке входа. По словам Google, большинство ходов агента превышают этот порог.

Затем проверьте это по данным, а не на веру: во втором и последующих запросах с общим длинным префиксом total_cached_tokens (Interactions) или cachedContentTokenCount (generateContent) должен быть больше нуля. Если он остаётся 0, проверьте, что префикс совпадает побайтно, включая метки времени или ID запросов, которые вы, возможно, вставляете в начало.

Ответы длиннее 64K: фоновое выполнение

Один синхронный ответ Neon ограничен 65 536 токенами рассуждений и вывода вместе. Для длинной спецификации, большого плана рефакторинга или полного набора тестов Google рекомендует фоновое выполнение:

import time
from google import genai

client = genai.Client()
interaction = client.interactions.create(
    model="gemini-4-neon",
    input="Write a complete migration specification and test plan for this service.",
    background=True,
    generation_config={"max_output_tokens": 262144, "thinking_level": "high"},
)

while interaction.status in ("queued", "in_progress"):
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# Соединяем текст из всех hop продолжения по 64K.
text = "".join(
    content.text
    for step in interaction.steps
    if step.type == "model_output"
    for content in step.content
    if content.type == "text"
)
print("Status:", interaction.status)
print("Usage:", interaction.usage)
print(text)

Текст приходит в нескольких шагах model_output, потому что сервер продолжает генерацию hop по 64K, поэтому соединяйте их все (скрипт проверки выше делает то же самое). Фоновый interaction может выполняться до 24 часов; если он завершился с failed, повторите один раз, как указано в таблице статусов. Ещё две детали легко упустить. Если задать background без max_output_tokens, сервер всё равно остановится после 65 536 токенов. А фоновому выполнению нужно хранение, поэтому не сочетайте его со store=False. Верхняя граница — 1 048 576 минус ваши входные токены. Если хранить interaction нельзя, продолжение на стороне клиента описано в руководстве Google по длинной генерации (на английском).

Частые ошибки Gemini 4 Neon API и их исправление

Прежде чем что-либо менять, запишите эндпоинт, точный ID модели, проект, версию SDK и полное тело ошибки (без ключа). Исправляйте самый ранний слой, на котором произошёл сбой.

СимптомВероятная причина в NeonИсправление
Ошибка доступа или квоты с ключом, который работает для HydrogenКлюч относится к проекту на бесплатном уровне; Neon доступна только на платномИспользуйте ключ из проекта с активной платной оплатой (шаг 1)
Модель не найденаОпечатка, выдуманный суффикс вроде -preview или шлюз, который не маршрутизирует NeonИспользуйте gemini-4-neon с generativelanguage.googleapis.com
400 на thinking_levelОтправлен minimal (отклоняется в Gemini 4), смешаны структуры полей Interactions и generateContent или вместе с уровнем отправлен старый thinkingBudgetИспользуйте low/medium/high/xhigh; приведите имена полей в соответствие с эндпоинтом; удалите thinkingBudget
Ошибка валидации 400 с параметрами сэмплированияtemperature, top_p или top_k вне диапазонаУберите параметры сэмплирования; значения в диапазоне всё равно игнорируются
Запрос падает после переноса кода кэшированияОсталась ссылка на cached_content / cachedContents (явное кэширование не поддерживается)Удалите её; полагайтесь на неявное кэширование
MAX_TOKENS, incomplete или пустой текстНизкий max_output_tokens израсходован на рассужденияВерните 65 536, используйте фоновое выполнение для долгой работы или осознанно снизьте уровень рассуждений
MALFORMED_FUNCTION_CALLМодели велели выдавать вызовы инструментов в виде JSON обычным текстом, не объявив инструментыОбъявите инструменты через function calling или используйте структурированный вывод
Ошибки подписи в многоходовой работе с инструментамиПодписи рассуждений потеряны или скопированы между параллельными вызовамиИспользуйте previous_interaction_id или возвращайте предыдущие ходы без изменений; см. наше исправление ошибки об отсутствующей подписи рассуждений
Тайм-аут клиента на сложных промптахРассуждения на high/xhigh занимают минутыУвеличьте HTTP-тайм-аут минимум до 15 минут или используйте фоновое выполнение
429Лимиты скорости действуют и на платном уровнеСнизьте параллельность и делайте паузы перед повтором; см. наше руководство по повторам после 429 (на английском)

Большинство строк взяты прямо из чек-листа Google по миграции на Neon. Разобранные примеры диагностики маршрута, квот и ответов на родственной модели есть в нашем разборе ошибок Gemini 4 Argon API; значения, специфичные для Argon (уровень рассуждений по умолчанию, доступные уровни), к Neon не относятся. Ошибки Carbon, Neon и Hydrogen, включая пустые и обрезанные ответы, собраны в нашем руководстве по ошибкам Gemini 4 Carbon, Neon и Hydrogen.

Можно ли вызвать Gemini 4 Neon через Ofox?

По состоянию на 19 ноября 2026 года — нет. Список моделей Ofox вернул Gemini 4 Hydrogen и Argon, но не Neon, а путь страницы модели Neon вернул 404. Не направляйте код выше на базовый URL Ofox: эндпоинт Interactions и ключ Ofox относятся к разным системам, и маршрута к Neon нет.

Чтобы проверить позже, ищите google/gemini-4-neon в списке моделей Ofox (GET https://api.ofox.io/v1/models с вашим ключом Ofox) или на ofox.ai/models. Если модель появится, на её странице будут указаны поддерживаемые протоколы и текущая цена. Формат запросов к моделям Gemini в Ofox описан в документации Ofox по Gemini API. Эндпоинт и аутентификацию берите оттуда; не рассчитывайте, что нативный для Google код из этой статьи заработает без изменений.

Если модель Gemini 4 через Ofox нужна уже сейчас, в каталоге есть Gemini 4 Hydrogen, и руководство по её настройке описывает маршрут через Ofox. Как Neon выглядит на фоне флагманов конкурентов, с которыми её сравнивает Google, разобрано в материале Gemini 4 Neon, Claude Opus 5.5 и GPT-6.2 Sol: сравнение.

Чек-лист приёмки первого вызова

Прежде чем считать интеграцию с Neon готовой, сохраните запись без секретов:

  • ID модели gemini-4-neon, эндпоинт, версия SDK и идентификатор проекта.
  • Один сохранённый ответ, который проходит проверку: completed или STOP, непустой текст.
  • Строка использования, где токены рассуждений и кэшированного входа записаны отдельно.
  • Отправленные thinking_level и max_output_tokens, явно прописанные в коде, а не унаследованные от значений по умолчанию.
  • Все ошибки, которые встретились, и изменения, которые их исправили.

Когда эта база готова, добавляйте инструменты, длинные документы или фоновые задачи по одному. Если что-то сломается, вы будете знать, что дело в новой части.

Связанная документация