Gemini API store=true by default: a privacy checklist for new projects

If you create a new paid Gemini API project, your Generate Content requests are now logged by default. Google's changelog dated October 26, 2026 says new paid-tier projects "now store requests by default (store=true), matching the Interactions API." Existing projects keep their current setting. If you handle client data, that default is now your problem to review, and the fix is one line per call plus one toggle.

This is a checklist for developers and freelancers, not legal advice. Everything below was read on Google's pages on 2026-10-30. I did not call the API; the one script I ran is a static code checker, with real output below.

What exactly changed on October 26, 2026?

Three facts, each from Google's own pages:

1. Generate Content, new projects. Per the logs and datasets page, logging is on by default "for Generate Content API calls in projects created on or after October 26, 2026."
2. Generate Content, old projects. Projects created before that date keep their current setting. The page says storage is off unless it was previously enabled in AI Studio.
3. Interactions API. It already stored requests by default, and the page says logging is on by default for it. Turning Interactions logging off in the Settings panel also stops the API from automatically storing and retrieving conversation history, "unless explicitly overridden per-request."

Storage is available only on the paid tier. It covers generateContent, batch and streaming calls, and Interactions calls (excluding Managed Agents), including calls through the OpenAI-compatibility endpoints. The page lists things that are not logged: Imagen and Veo, the embedding models, the Robotics model, inputs containing videos, GIFs or PDFs, and Public Preview Agents.

That last list matters. A PDF-in-prompt request being excluded from logs is not a privacy feature you should design around. It is a coverage gap in the logging feature, and it says nothing about what happens to the file elsewhere in the request path.

How long are stored requests kept, and who can read them?

From the logs policy page:

• Default maximum retention is 55 days, after which logs are "automatically marked for deletion."
• Paid projects can change this in AI Studio to 7, 14, 28 or 55 days.
• Logs saved into datasets "don't have set retention periods."
• Default logs: prompts and responses are not used for product improvement or development.
• Shared datasets: the page says the dataset may be used to develop and improve Google products and that human reviewers may read, annotate and process what you share. There is an opt-out when creating the dataset.

The Interactions page adds a retention line for that API: 55 days on the paid tier and 1 day on the free tier, with the same 7, 14, 28, 55 option for paid projects. I read that page through a summarising fetch tool, so confirm the free-tier number yourself.

One gap to be honest about. The page says logs are "marked for deletion" after the window. It does not say how soon after that the data is actually removed, so do not promise your client "deleted on day 55."

This also updates one line in our data retention by vendor table, which said the Gemini paid-tier log duration was unknown on the terms page. The logs policy page does give a number for the logging feature. The terms page still says "limited period" for abuse logging, so those are two separate things.

How do I set store=false in the Gemini API?

Google's own Python example uses a plain dictionary config. This is the shape from the page, with the value flipped to opt out (the page prints True with a comment saying to set False to disable):

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Summarise this support ticket.",
    config={"store": False},  # per-request opt-out; overrides the project setting
)
print(response.text)

For the Interactions API, the page shows store=False as a keyword argument to client.interactions.create(...). The REST reference for models.generateContent and streamGenerateContent lists a boolean store field in the request body: "Configures the logging behavior for a given request," and "If set, it takes precedence over the project-level logging config." The reference does not state a default.

Trade-off for Interactions: store=false prevents using previous_interaction_id on later turns and is incompatible with background execution, per the Interactions page. If you use server-side conversation state, you either keep storage for that call or send the history yourself.

I have not run these calls. The model name in the snippet is just one valid ID from Google's model page; swap in your own.

How do I set it for the whole project?

In AI Studio, open the Logs Dashboard and use the Settings panel. Google's page says you can toggle logging on or off independently for generateContent and for the Interactions API. If you want a safe default, switch Generate Content logging off at project level and turn on per-request storage only where you need logs for debugging.

If you see no Generate Content logs in an older project, the page says logging must be enabled in the settings panel to view them. That is expected behaviour for projects created before October 26.

Which of your calls rely on the default? A static check

Project settings can drift, so make the code say what it means. This small checker reads Python source with ast and flags generate_content, generate_content_stream and interactions.create calls that do not set store. It is a heuristic: it cannot see your project toggle, and it reports "unknown" when the config is a variable.

import ast, pathlib, sys

GEN = {"generate_content", "generate_content_stream"}

def sets_store(call):
    for kw in call.keywords:
        if kw.arg == "store":
            return ast.unparse(kw.value)
        if kw.arg == "config":
            v = kw.value
            if isinstance(v, ast.Dict):
                for k, val in zip(v.keys, v.values):
                    if isinstance(k, ast.Constant) and k.value == "store":
                        return ast.unparse(val)
            elif isinstance(v, ast.Call):
                for k in v.keywords:
                    if k.arg == "store":
                        return ast.unparse(k.value)
            else:
                return "?"
    return ""

def audit(path):
    bad = 0
    for node in ast.walk(ast.parse(path.read_text())):
        if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
            name = node.func.attr
            inter = name == "create" and "interactions" in ast.unparse(node.func)
            if name in GEN or inter:
                val = sets_store(node)
                status = ("UNKNOWN (config is a variable)" if val == "?"
                          else "DEFAULT (no store set)" if val == ""
                          else f"explicit store={val}")
                bad += val == ""
                print(f"{path}:{node.lineno}: {ast.unparse(node.func)} -> {status}")
    return bad

target = pathlib.Path(sys.argv[1])
files = [target] if target.is_file() else sorted(target.rglob("*.py"))
total = sum(audit(f) for f in files)
print(f"\n{total} call(s) rely on the default")
sys.exit(1 if total else 0)

I ran it on a five-call sample file (two defaults, two explicit opt-outs, one config passed as a variable). Real output:

/tmp/L2/sample/app.py:6: client.models.generate_content -> DEFAULT (no store set)
/tmp/L2/sample/app.py:9: client.models.generate_content -> explicit store=False
/tmp/L2/sample/app.py:16: client.interactions.create -> DEFAULT (no store set)
/tmp/L2/sample/app.py:19: client.interactions.create -> explicit store=False
/tmp/L2/sample/app.py:23: client.models.generate_content -> UNKNOWN (config is a variable)

2 call(s) rely on the default

It exits with status 1 when it finds defaults, so you can drop it into CI. It will miss wrapper functions and the REST or JavaScript paths.

The checklist

Run this when you start any Gemini project, and again when you inherit one.

1. Find the project's creation date. Created on or after October 26, 2026 means Generate Content logging is on unless you turned it off. Older means off unless someone enabled it.
2. Check both toggles in the AI Studio Settings panel: Generate Content and Interactions.
3. Confirm the tier. Storage is paid-tier only; on the free tier the data-use terms differ, as covered in the vendor table.
4. Decide per feature, not per project: debugging logs for internal tools can stay on, calls with personal data should say store=False.
5. Set a retention window (7, 14, 28 or 55 days) that matches what you told the client.
6. Do not share datasets that contain real user data unless the client has agreed to the sharing terms.
7. Redact before you send. The cheapest privacy control is not sending the identifier at all. The content moderation layer post shows an input filter pattern you can adapt.
8. Write it down. One sentence in the project README: which toggles, which window, which calls opt out.
9. For India-based work, read the Act yourself or ask a professional. Our DPDP checklist for AI app developers is a developer's orientation, not legal advice.

What I could not verify

• The exact default behaviour of the store field in the REST reference; the page states none.
• How long after "marked for deletion" data is removed.
• Whether OpenAI-compatibility calls pick up the new project default in practice. The page says they are covered by logging; I did not test it.
• Anything about enterprise or Vertex AI storage; this post is about the Gemini Developer API only.

Sources, read 2026-10-30: Gemini API changelog, logs and datasets, logs policy, Interactions API, GenerateContent reference.