Gemini 2.5 Flash and 2.5 Pro Deprecation (December 1): What Breaks When They Auto-Redirect to 3.5 Flash-Lite and 3.8 Flash, and How to Migrate

In the Gemini API, gemini-2.5-flash and gemini-2.5-pro will automatically redirect to other models starting December 1, 2026. Your requests will still go through without changing the model name, but a newer model will answer them, and you'll be billed at the newer model's rates. Google announced the plan in the Gemini API changelog on November 2, 2026.

According to an email Google sent to AI Studio users, if you send a single text or image request and get one answer back, your code will keep working as is. The trouble is with code that uses function calling, conversation history you build yourself, or fine-grained settings such as thinking_budget and temperature. The new models are stricter about what they accept, so requests can fail with an HTTP 400 error or settings can be silently ignored. This article shows how to check whether your code is affected and how to migrate before December 1 (checked November 7, 2026).

1. What changes

According to Google's "Gemini deprecations" page and the changelog, the two models will be handled as follows. Neither can be selected in Google AI Studio anymore, and only users who were already using them can still call them through the API.

Sources: Google, "Gemini API changelog" (November 2, 2026 entry) and "Gemini deprecations" (checked November 7, 2026). Note that 2.5 Pro redirects to the Flash line, not to a Pro model.

Despite the similar names, the following models are not part of the December 1 redirect.

The shutdown dates in the table mean "as early as this date," and Google says it will announce the exact date in advance. The auto-redirect for gemini-2.5-flash and gemini-2.5-pro has a fixed date: "December 1, 2026."

1. November 2, 2026Google announces the changePosted in the changelog. The models can no longer be selected in AI Studio.
2. Now (November 7, 2026)Migration windowYou can switch to the new model names and test on your own schedule.
3. December 1, 2026Auto-redirectRequests that use the old names are answered by the new models and billed at the new models' rates.
4. Through December 31, 2026 → from January 1, 20273.8 Flash introductory pricing endsThe rates for the 2.5 Pro redirect target go up (Section 4).

2. Is your code affected? (checklist table)

The two new models follow the request rules introduced with Gemini 3.6 Flash and 3.5 Flash-Lite and later models. Here are the differences listed in Google's migration guides, organized by how your code is written.

Sources: Google, "What's new in Gemini 3.6 Flash and 3.5 Flash-Lite" and "What's new in Gemini 3.8 Flash," and an email Google sent to AI Studio users (November 3, 2026). The HTTP 400 error for candidate_count of 2 or more comes from Google's email; that it isn't supported in Gemini 3 and later comes from the migration guide. Matching id and name in function calling appears in both the migration guide and the email. The 3.8 Flash migration guide says call_id, but in generateContent the FunctionResponse field is named id (an optional field in the API reference).

The fastest way to find the affected spots in your code is a string search. The Python and JavaScript SDKs and REST JSON spell the names differently (thinking_budget vs. thinkingBudget, for example), so use patterns that catch both.

# Affected model names (excluding 2.5-flash-lite)
grep -rnE "gemini-2\.5-(flash|pro)([^-]|$)" .

# Settings that break or are ignored
grep -rnE "thinking_?[bB]udget|temperature|top_?[pPkK]|candidate_?[cC]ount" .

# Places that return function call results
grep -rnE "function_?[rR]esponse|FunctionResponse" .

If you keep model names in config files or environment variables, search those too. Once you match each hit to a row in the table, you'll know how much needs fixing.

3. Migration steps

We recommend that you switch to the new model names yourself, pass your tests, and then ship to production rather than waiting for December 1. If you leave it to the auto-redirect, everything that breaks will surface in production at once. The code examples use generateContent in Google's Python SDK (google-genai).

1. Change the model names: gemini-2.5-flash → gemini-3.5-flash-lite, gemini-2.5-pro → gemini-3.8-flash
2. Set the amount of thinking with thinking_level: remove thinking_budget and choose the level that fits the task
3. Remove sampling settings: temperature, top_p, and top_k
4. Fix your function calling history: keep thought_signature, and include id and name in FunctionResponse
5. Stop prefilling and drop candidate_count
6. Test with heavy inputs before rolling out: run workflows that call tools many times and long conversations, and check errors, answer quality, and token usage

3-1. Change the model names

Changing a name is a one-line edit, but the same name often appears in several places, so use the searches in Section 2 to find every instance before you change them. As soon as you switch, you're billed at the new model's rates.

3-2. Replace thinking_budget with thinking_level

Gemini 2.5 set the number of tokens used for thinking with a numeric thinking_budget. The new models replace it with thinking_level, which takes a named level. The available levels and the default differ by model.

Sources: the table in Google's "Thinking" page and each migration guide (checked November 7, 2026).

Watch out for the fact that the 2.5 Flash redirect target defaults to minimal. 2.5 Flash thought by default, but 3.5 Flash-Lite barely thinks unless you tell it to. Google's migration guide says minimal is fine for high-volume extraction, routing, and classification, but recommends medium or high for tool calls, code execution, and multi-step reasoning, because at low levels tool-using workflows can stop partway through.

from google import genai
from google.genai import types

client = genai.Client()

# Before: gemini-2.5-flash
# config=types.GenerateContentConfig(
#     temperature=0.2,
#     thinking_config=types.ThinkingConfig(thinking_budget=1024),
# )

# After: gemini-3.5-flash-lite
response = client.models.generate_content(
    model="gemini-3.5-flash-lite",
    contents=prompt,
    config=types.GenerateContentConfig(
        system_instruction="Output JSON only. Do not add any preamble.",
        thinking_config=types.ThinkingConfig(thinking_level="medium"),
    ),
)
print(response.text)

If you send JSON directly over REST, change "thinkingBudget": 1024 to "thinkingLevel": "medium" inside generationConfig.thinkingConfig. The API reference describes thinkingLevel as a field for Gemini 3 and later and says sending it to earlier models returns an error. Change the model name and thinking_level in the same change.

There is no official mapping from the numeric budgets you used on 2.5 to the levels. Start with the guide below and adjust based on answer quality and token usage.

This guide is based on the per-level use cases described in Google's migration guides. Thinking tokens are billed at the output rate, so raising the level also raises the cost.

3-3. Remove temperature, top_p, and top_k

Starting with Gemini 3.6 Flash and 3.5 Flash-Lite, Google deprecated temperature, top_p, and top_k. On the current new models they are ignored without an error, and Google says future generations will return an HTTP 400 error. Because no error appears, this is easy to miss. Workflows that set temperature to 0 to get consistent answers may stop being consistent.

Google's recommended alternative is to state output rules clearly in the system instruction (for example, "Output JSON only" or "Do not add any preamble"). If you need a strictly consistent format, use structured output (the feature that takes a JSON schema).

The Claude API has also changed how temperature works on newer models. For the same line of thinking, see ""temperature is deprecated for this model": causes and fixes."

3-4. Fix your function calling history

Gemini 3 models return thought signatures in their responses: encrypted representations of the model's internal reasoning before it answers. If the signature isn't sent back on the next turn, the model can't continue its earlier reasoning. In generateContent, the signature is in the thoughtSignature of parts such as function calls.

The fragile pattern is rebuilding the model turn from just the name and arguments and adding it to the history. Rebuilding it drops the signature.

# ❌ Rebuilding the model turn from just the name and args drops thought_signature
contents.append(types.Content(role="model", parts=[
    types.Part(function_call=types.FunctionCall(name=call.name, args=call.args))
]))

The fix is to return the content you received to the history unchanged. Also, in the function result (FunctionResponse), include the same id and name as the FunctionCall the model returned.

config = types.GenerateContentConfig(
    tools=[weather_tool],
    thinking_config=types.ThinkingConfig(thinking_level="medium"),
)
contents = [types.Content(role="user", parts=[
    types.Part.from_text(text="What's the weather in Boston?")
])]

response = client.models.generate_content(
    model="gemini-3.5-flash-lite", contents=contents, config=config)
call = response.function_calls[0]

# ✅ Append the model turn exactly as received (it contains the signature)
contents.append(response.candidates[0].content)

result = get_weather(**call.args)
contents.append(types.Content(role="user", parts=[
    types.Part(function_response=types.FunctionResponse(
        id=call.id,      # same value as the FunctionCall id
        name=call.name,  # same value as the FunctionCall name
        response={"result": result},
    ))
]))

response = client.models.generate_content(
    model="gemini-3.5-flash-lite", contents=contents, config=config)
print(response.text)

When a function result includes images or other media, put them inside the FunctionResponse (in parts) rather than as separate parts. Google's "Function calling" page says the SDKs handle signatures automatically. If you let the SDK's chat feature (client.chats) hold the history, you don't need to pass signatures yourself. You need to be careful when you save the history in your own database or another format and rebuild it on every request. Check that your storage format doesn't drop the signatures.

The API reference lists MISSING_THOUGHT_SIGNATURE (Request has at least one thought signature missing) as a finishReason value indicating that a signature is missing. If you see this value or an error like it in your logs, suspect how you build the history first.

import json

# In the Interactions API, function declarations are written as dicts (a different shape from weather_tool in generateContent)
interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="What's the weather in Boston?",
    tools=[weather_tool_dict],
)
for step in interaction.steps:
    if step.type == "function_call":
        result = get_weather(**step.arguments)
        interaction = client.interactions.create(
            model="gemini-3.8-flash",
            input=[{
                "type": "function_result",
                "name": step.name,
                "call_id": step.id,
                "result": [{"type": "text", "text": json.dumps(result)}],
            }],
            tools=[weather_tool_dict],
            previous_interaction_id=interaction.id,
        )
print(interaction.output_text)

The migration guide also points to workarounds for cases where text before a tool call causes Malformed_Function_Call, in the "Workarounds for pre-tool text requirements" section of the Function calling page.

3-5. Stop prefilling and drop candidate_count

Prefilling the start of the answer (making the last non-empty turn in contents a model turn) returns an HTTP 400 error on the new models. Google's migration guide lists this pattern as one to avoid.

{
  "contents": [
    {"role": "user", "parts": [{"text": "Translate 'Hello world' to Spanish."}]},
    {"role": "model", "parts": [{"text": "Translation:"}]}
  ]
}

If you prefilled to suppress a preamble or to force a JSON answer, write the rule in the system instruction or use structured output.

response = client.models.generate_content(
    model="gemini-3.5-flash-lite",
    contents="Translate 'Hello world' to Spanish.",
    config=types.GenerateContentConfig(
        system_instruction="Output only the translation. Do not add any preamble.",
    ),
)

candidate_count (the setting that returns multiple answers from one call) isn't supported in Gemini 3 and later, and setting it to 2 or more returns an HTTP 400 error. If you need multiple options, split them into multiple calls.

Google also provides a Gemini API skill to help with this migration for coding agents that support skills ("Coding agents"). Even if you use it, run the tests on the fixed code yourself.

4. How pricing changes

The rates of the redirect targets are about the same coming from 2.5 Flash and lower coming from 2.5 Pro. However, 3.8 Flash is on introductory pricing through December 31, 2026, and its rates go up on January 1, 2027. After the increase, output stays cheaper than 2.5 Pro, but input becomes more expensive than 2.5 Pro (for prompts of 200K tokens or less). All prices below are standard paid-tier rates in US dollars per 1 million tokens.

Source: the Standard table in Google's "Gemini Developer API pricing" (checked November 7, 2026). Check the pricing page for discounted tiers such as Batch and Flex. 3.8 Flash rates don't vary by prompt length.

Let's run the numbers for a 2.5 Pro workload. With 10 million input tokens and 2 million output tokens a month (all prompts of 200K tokens or less), 2.5 Pro costs $12.50 + $20.00 = $32.50. The same token counts on 3.8 Flash cost $7.50 + $7.50 = $15.00 in December 2026 and $15.00 + $15.00 = $30.00 from January 2027.

That said, the token counts won't necessarily stay the same. Google says 3.8 Flash is designed to use more tokens on long, complex tasks. It also says you can reduce that for everyday work by lowering thinking_level. When moving from 2.5 Flash to 3.5 Flash-Lite, raising the level above the default minimal also increases output tokens spent on thinking. Even when the rates are the same or lower, your bill depends on the level you choose. If you record the token counts in responses (usage_metadata) during testing, you can estimate your December bill.

Grounding with Google Search is also counted differently. For 2.5 Flash and 2.5 Pro, the first 1,500 requests per day were free, and after that it cost $35 per 1,000 "grounded prompts." For 3.5 Flash-Lite and 3.8 Flash, the first 5,000 requests per month are free across all Gemini 3 and later models, after which it costs $14 per 1,000 search queries, with a limit of 1,500 requests per day. If one request runs several searches, each search is billed. If you rely heavily on grounding, review your counts.

For Gemini pricing as a whole (paid app plans vs. the API), see "Gemini pricing and free features." For how API pricing works (tokens, input, and output), see "What is an AI API?"

5. What happens after December 1

Here's what happens if you do nothing, by how your code is written.

• No model-name errors: requests that still use the names gemini-2.5-flash and gemini-2.5-pro reach the new models
• You're billed at the new models' rates: the 2.5 Pro redirect target's rates go up again on January 1, 2027
• Prefilled requests and requests with candidate_count of 2 or more stop with an HTTP 400 error: function calling that drops signatures because you rebuild the history yourself can also cause errors or unexpected behavior
• Some answers change without any error: settings such as temperature are ignored, and the 2.5 Flash redirect target barely thinks by default. This shows up as tool-using workflows stopping partway through or answers varying more

Changes that don't produce errors rarely show up in monitoring metrics. Comparing the failure counts of the checks that validate answer format (whether the output parses as JSON, whether required fields are present) before and after the switch will help you catch them.

6. Should you stay on the auto-redirect target?

The auto-redirect targets are the models Google recommends as the replacement for each. Still, their character differs from what you had before.

Flash 2.5 Flash → 3.5 Flash-Lite moves you to the "Lite" line at the same rates. Google reports that 3.5 Flash-Lite scored 18.0% on the reasoning benchmark HLE versus 11.0% for 2.5 Flash, and 74.5% versus 63.7% on the chart-understanding benchmark CharXIV (Google's own measurements). If your work is mostly high-volume extraction or classification, moving as is makes sense. If it's mostly multi-step agents or code generation and you want better answers, gemini-3.6-flash, which Google's comparison table lists for code generation and multi-step tasks, is another option. Its introductory pricing through December 31, 2026 is $0.75 input and $3.75 output, rising to $1.50 and $7.50 from January 1, 2027, so it costs more than 3.5 Flash-Lite.

Pro 2.5 Pro → 3.8 Flash moves you from the Pro line to the Flash line. Google calls 3.8 Flash its "most intelligent Flash model" and positions it for long-running software development and agents. Compared with 2.5 Pro, its output rate stays lower even from 2027 ($10.00 → $7.50), while its input rate becomes higher from 2027 ($1.25 → $1.50 for prompts of 200K tokens or less).

If answer quality is your top priority, the more expensive Gemini 4 Argon (gemini-4-argon) is also an option. Its introductory pricing through November 30, 2026 is $2.00 input and $10.00 output, rising to $4.00 input and $20.00 output from December 1, and there is no free tier ("Pricing," checked November 7, 2026).

Whichever model you choose, switch the name, run the same tests, and decide by comparing answer quality, errors, and token counts. For the knowledge cutoffs and positioning of other Gemini models, see "Generative AI knowledge cutoff dates compared."

Changes in response shape and setting handling when you switch models aren't unique to Gemini. The same kind of problem when switching to a newer model in the Claude API is covered in "'ThinkingBlock' object has no attribute 'text': cause and fix."

Summary

• From December 1, 2026, gemini-2.5-flash auto-redirects to gemini-3.5-flash-lite and gemini-2.5-pro to gemini-3.8-flash, billed at the target model's rates
• Single-turn text and image requests keep working. gemini-2.5-flash-lite is not affected
• Function calling that drops signatures because you rebuild the history yourself, prefilling, and requests with candidate_count of 2 or more can return HTTP 400 errors. Google requires id and name in FunctionResponse (with the SDK's chat feature, the SDK carries the signatures)
• Replace thinking_budget with thinking_level. 3.5 Flash-Lite defaults to minimal, so use medium or higher for tools and multi-step work. Settings such as temperature are ignored
• Rates are about the same coming from 2.5 Flash and lower coming from 2.5 Pro. But 3.8 Flash goes up on January 1, 2027 (input becomes more expensive than 2.5 Pro), and token counts also change with the thinking level
• Don't wait for December 1: switch the model names, test with heavy inputs, then ship to production

FAQ

Q. If I call gemini-2.5-flash on December 1, will I get a model-not-found error?

A. No. According to Google's documentation, requests are automatically redirected to gemini-3.5-flash-lite. However, the new model answers them, and you're billed at the new model's rates. Function calling that drops signatures because you rebuild the history yourself, prefilling, and requests with candidate_count of 2 or more can return HTTP 400 errors.

Q. I got a thought signature error. What should I fix?

A. The part of your code that builds the conversation history. Check whether you rebuild the content the model returned on the previous turn from just the name and arguments. If you return the content you received to the history unchanged, the signature goes back with it. If you use the SDK's chat feature or previous_interaction_id in the Interactions API, signatures are handled automatically.

Q. How much does gemini-3.5-flash-lite cost?

A. On the paid tier, input is $0.30 per 1 million tokens (for text, image, video, and audio alike) and output is $2.50 (checked November 7, 2026). Compared with 2.5 Flash, text, image, and video input and output are the same, and audio input drops from $1.00 to $0.30.

Q. I set thinking_budget to 0 to turn thinking off. What should I do now?

A. On 3.5 Flash-Lite, either omit thinking_level (the default is minimal) or set it to "minimal". 3.8 Flash has no minimal level and returns an error, so use the lowest level, "low".

Update log

• November 7, 2026First published. Written after checking the Gemini API changelog (November 2, 2026), Gemini deprecations, the migration guides (3.6/3.5 Flash-Lite and 3.8 Flash), pricing, Thinking, and the API reference.

Sources

• Google: Gemini API changelog, Gemini deprecations, Pricing
• Google: What's new in Gemini 3.6 Flash and 3.5 Flash-Lite, What's new in Gemini 3.8 Flash
• Google: Thinking, Function calling, Migrating to the Interactions API, generateContent API reference
• Email from Google to Google AI Studio users, "Gemini 2.5 Flash redirects to 3.5 Flash-Lite Dec 1" (November 3, 2026)