How do you use Gemini 3.5 Flash for fast, cheap tasks?

Gemini 3.5 Flash is Google's newest Flash model, and it launched as generally available, which means Google considers it stable for production use. "Flash" is Google's name for its faster, lower-cost line, but this one is not a stripped-down model: Google positions it for coding and agent work as well. That makes it tempting to use for everything. For everyday jobs, the savings come from three settings you control: how much the model thinks, whether the job can wait, and how much text you send.

All three are explained below, followed by a worked example: sorting 500 customer reviews for well under a dollar.

Setting 1: the thinking level

Gemini 3.5 Flash is a reasoning model: before answering, it can produce hidden "thinking" text that it uses to work the problem out. That thinking is billed as output tokens. A token is a small piece of text, often a word or part of one, and APIs charge per million of them.

Google's developer guide lists four thinking levels:

The default changed with this release: it is now medium, where the earlier Gemini 3 Flash preview defaulted to high. So if you do nothing, you already save compared with that preview. For routine work, set it lower explicitly. Google also notes that minimal does not switch thinking off completely; the model may still think a little on hard inputs.

from google import genai
from google.genai import types

client = genai.Client()   # reads your GEMINI_API_KEY
response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Rewrite this sentence in plain English: 'Remittance is due upon receipt.'",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="minimal")
    ),
)
print(response.text)

Google recommends leaving temperature and similar sampling settings at their defaults for all Gemini 3 models; if you want consistent output, write explicit rules in a system instruction instead.

Setting 2: the Batch API

Many jobs do not need an answer this second: tagging last month's support tickets, summarizing a folder of reports, translating a product catalog. Google's Batch API accepts a large set of requests at once, processes them in the background, and charges 50% of the standard price. The target turnaround is 24 hours, though Google says most jobs finish much sooner. A job still waiting or running after 48 hours expires without results, so check on it.

On the paid tier, Gemini 3.5 Flash costs $1.50 per million input tokens and $9.00 per million output tokens (thinking included). Through the Batch API those become $0.75 and $4.50.

A worked example: sorting 500 reviews

A small online shop wants each of its 500 latest reviews labeled as shipping, product quality, price, customer service or other, plus positive or negative. Nobody needs the result within the hour, so it goes to the Batch API with thinking set to low.

from google import genai

client = genai.Client()
rules = ("Label the review with one topic: shipping, product quality, price, customer service or other. "
         "Then label it positive or negative. Reply as JSON: {\"topic\": ..., \"sentiment\": ...}")

requests = [
    {"contents": [{"parts": [{"text": review}], "role": "user"}],
     "config": {"system_instruction": {"parts": [{"text": rules}]},
                "thinking_config": {"thinking_level": "low"},
                "response_mime_type": "application/json"}}
    for review in reviews          # your list of 500 review texts
]

job = client.batches.create(model="gemini-3.5-flash", src=requests,
                            config={"display_name": "review-labels-may"})
print(job.name)   # save this; check later with client.batches.get(name=job.name)

When client.batches.get reports the state JOB_STATE_SUCCEEDED, the answers are in job.dest.inlined_responses, one per review, each holding either a response or an error. Inline requests suit jobs under 20 MB in total; for bigger ones, Google's guide uses a JSON Lines file, with one request per line.

Estimating the cost (illustrative numbers). Suppose each request, with the rules, averages 250 input tokens, and each answer plus its thinking averages 100 output tokens. That is 125,000 input tokens and 50,000 output tokens. At batch prices: 0.125 × $0.75 + 0.05 × $4.50 ≈ $0.09 + $0.23 = about $0.32 for all 500. The same job through the standard API would cost about twice that. Your real numbers depend on review length and how much the model thinks, which is why the next step matters.

Which tasks does it handle well?

Google aims Gemini 3.5 Flash at work that needs to be quick and repeated many times: coding iterations, agent loops where the model calls tools step after step, and long multi-step workflows. It keeps a 1-million-token context window (the amount of text it can consider at once) and can write up to about 65,000 tokens in one answer, so long documents fit comfortably. One current gap: Google's guide says it does not yet support Computer Use, the feature that lets a model operate a screen.

For everyday, high-volume jobs, it handles classification, extraction into a fixed format, summarizing, rewriting and translation well at low thinking levels; these tasks have clear right answers and little need for long reasoning. Keep medium or high for jobs where a wrong answer is costly or the steps are many: debugging, planning, or analysis you will act on.

Two habits keep costs predictable. Send only the text the task needs, because every input token is billed. And in long conversations, remember that Gemini 3.5 Flash carries its earlier reasoning forward, which Google notes increases the input token count turn by turn; start a fresh conversation for unrelated questions.