Gemini Interactions API: Does It Cut Chatbot Costs?
Google’s Gemini Interactions API stores each conversation turn on Google’s side. Instead of sending the whole chat history with every message, your code sends the new message plus a previous_interaction_id, and Google picks up where the last answer left off. Google’s own documentation says this makes it easier to “utilize implicit caching for the conversation history, which improves performance and reduces costs.” On 21 November at least one agent framework moved its Gemini calls onto it for exactly that reason.
So does it make a WordPress chatbot cheaper? A support bot is not a generic chat app. Every visitor message comes with a fresh block of knowledge-base excerpts, and that changes the arithmetic. On 22 November 2026 we sent the same six-message support conversation to Gemini 4 Carbon, Gemini 4 Hydrogen and Gemini 3.8 Flash four different ways, 144 messages in all, and priced every token Google reported.
The short answer: not with the obvious setup. Stored turns cached exactly as promised: in 27 of 30 follow-up messages Google billed the entire earlier conversation at the cached rate. But the stored history also holds every earlier knowledge-base excerpt, so the input billed per conversation nearly tripled, from about 27,000 tokens to 77,000 to 83,000. On Gemini 4 Carbon, 1,000 six-message conversations cost $52.66 in MxChat’s current layout and $55.93 with stored turns. Stored turns cost more on all three models, and the median answer was 0.6 to 1.0 seconds slower. The one layout that came out cheaper on Carbon and Flash kept the knowledge base out of the stored history entirely. The details, and what each setup costs after Carbon doubles on 1 December, are below.
What the Interactions API changes, in one table
Both APIs run the same Gemini models at the same per-token prices. Google’s pricing page lists no separate rate for the Interactions API, and the usage object it returns bills input, cached input, output and thinking tokens exactly as generateContent does. What changes is who keeps the conversation.
generateContent (what MxChat uses) | Interactions API | |
|---|---|---|
| Endpoint | POST /v1beta/models/{model}:generateContent | POST /v1beta/interactions |
| Who holds the history | Your site. Every request carries the earlier turns in contents | Google. Send previous_interaction_id and only the new input |
| System instruction | systemInstruction, or a first user turn | system_instruction. Applies only to the interaction it is sent with, so it must be sent every time |
| Are earlier turns billed again? | Yes, as input, because you send them | Yes, as input. In our test the stored part was almost always billed at the cached rate |
| Thinking level | generationConfig.thinkingConfig.thinkingLevel | generation_config.thinking_level |
| Storage by default | On for paid-tier projects created on or after 26 October 2026; existing projects keep their setting | On. store=false turns it off, and also turns off previous_interaction_id |
| How long it is kept | Gemini API logs: 55 days by default, settable to 7, 14 or 28 | 55 days on the paid tier, 1 day on the free tier |
| Not available | – | Batch, explicit context caching (implicit caching works) |
That third row is the whole story. Stored turns do not stop you paying for the history. They move it to Google’s side, where it is far more likely to be billed at the cached input rate: $0.10 per million tokens on Carbon instead of $2.00, and $0.075 on Hydrogen and 3.8 Flash.
How we tested
We ran every request from the mxchat.ai WordPress server on 22 November 2026, against Google’s paid tier, with the same six-message conversation each time. A visitor asks four support questions (WooCommerce order lookup, whether Pinecone is needed, handoff to Slack or Telegram, and which API keys and models work), then a follow-up that only makes sense with the earlier answer (“does that order lookup also work for guests?”), then asks the bot to list the four topics. Every message carried the knowledge-base excerpts the plugin would retrieve for it, about 3,400 tokens, between MxChat’s ===== OFFICIAL KNOWLEDGE DATABASE CONTENT ===== markers.
We sent that conversation four ways:
| Setup | API | What goes in each request |
|---|---|---|
| A. MxChat today | generateContent | First user turn: [System Instructions] + system prompt + this message’s knowledge base. A model turn (“I understand and will follow these instructions.”). Then every earlier question and answer as plain text, then the new question. This is MxChat 3.2.28’s layout, read from the plugin source on 22 November. |
| B. Stateless, cache-friendly | generateContent | System prompt in systemInstruction, then the earlier questions and answers, then the knowledge base and the new question in the last user turn. The whole history is still sent every time. |
| C. Stored turns, knowledge base in the input | Interactions | system_instruction = system prompt. input = knowledge base + question. From the second message on, previous_interaction_id points at the last answer, so only the new input is sent. |
| D. Stored turns, knowledge base in the system instruction | Interactions | system_instruction = system prompt + this message’s knowledge base. input = the question alone. previous_interaction_id as in C. |
Each setup ran the conversation twice on three models: Gemini 4 Hydrogen, Gemini 4 Carbon and Gemini 3.8 Flash. Thinking level was the one MxChat’s model catalog sends for each (low on all three), temperature 0.7, 8,192 maximum output tokens. We priced each request from the token counts Google returned (usageMetadata on generateContent, usage on Interactions), with cached input at the cached rate and thinking tokens billed as output. Google’s pricing page lists no separate rate for the Interactions API, so we used the same per-token prices for both.
Results: what 1,000 six-message conversations cost
Each figure is the mean of two full conversations, priced at the rates in force on 22 November 2026: Gemini 4 Carbon $2 / $10 per million input / output tokens, Gemini 4 Hydrogen $1.50 / $7.50, Gemini 3.8 Flash $0.75 / $3.75, cached input at Google’s cached rates ($0.10, $0.075 and $0.075 per million).

| Model and setup | Input tokens per conversation | Of which cached | Cost per 1,000 conversations | Median seconds per answer |
|---|---|---|---|---|
| Gemini 4 Carbon | ||||
| A. MxChat today | 27,068 | 15% | $52.66 | 5.00 |
| B. Resend, system instruction | 27,327 | 4% | $60.11 | 5.16 |
| C. Stored turns, KB in input | 77,746 | 72% | $55.93 | 5.90 |
| D. Stored turns, KB in system instruction | 27,425 | 28% | $47.96 | 5.77 |
| Gemini 4 Hydrogen | ||||
| A. MxChat today | 26,943 | 50% | $44.65 | 3.59 |
| B. Resend, system instruction | 26,868 | 5% | $58.76 | 3.65 |
| C. Stored turns, KB in input | 83,338 | 72% | $61.90 | 4.21 |
| D. Stored turns, KB in system instruction | 32,811 | 26% | $58.44 | 4.59 |
| Gemini 3.8 Flash | ||||
| A. MxChat today | 26,438 | 17% | $18.49 | 2.40 |
| B. Resend, system instruction | 26,354 | 4% | $20.78 | 2.15 |
| C. Stored turns, KB in input | 76,870 | 72% | $22.09 | 3.12 |
| D. Stored turns, KB in system instruction | 26,382 | 27% | $16.75 | 3.27 |
All 144 messages were answered. Every setup remembered the earlier answer when asked whether the WooCommerce order lookup works for guests (every answer said it is for logged-in customers only), and every setup listed all four earlier topics at the end. Three of those final summaries on Gemini 3.8 Flash said “your own API keys” without naming OpenRouter, which our keyword check counted as a miss. None was wrong.
Why stored turns did not save money here
Look at what is in the history. In setup C each visitor message goes in with its own knowledge-base excerpts, about 3,500 tokens. Google stores the interaction as sent, so message 2 carries message 1’s excerpts, message 3 carries both earlier sets, and so on. By the sixth message Carbon billed 21,680 input tokens. MxChat’s layout billed 4,786 for the same message, because the plugin sends earlier turns as the plain question and answer text and attaches excerpts only for the current question.

The cache did its part. In 27 of the 30 follow-up messages in setup C, Google billed the entire previous interaction as cached input, down to the token: on Carbon’s first run, 4,106 cached after a 4,105-token first message, then 7,596, 11,345, 14,777 and 18,254. The three exceptions were all the second message of a conversation, where only 790 or 785 tokens came back cached. But a 90 to 95% discount on three times the tokens still adds up to more than paying full price on the smaller request. On Carbon, the input side of setup C cost $49.41 per 1,000 conversations against $46.57 for MxChat’s layout. On Flash it was $20.37 against $16.75.
Hydrogen widens the gap for a reason that has nothing to do with layout. Hydrogen thinks before answering at MxChat’s low setting, about 400 thinking tokens per message here, billed as output at $7.50 per million. Thinking varied from 113 to 924 tokens on the same message, and that alone moved one conversation’s cost by half. MxChat’s layout also had a head start on Hydrogen, most likely because it ran right after our setup check, which had sent the identical first prompts, so Google’s cache already held a 2,073-token prefix. That is why setup A shows 50% cached on Hydrogen. A busy site gets some of the same effect, because the system prompt at the front of every MxChat request is identical for every visitor.
The setup that was cheaper: keep the knowledge base out of the stored history
Setup D sends the system prompt and the current message’s excerpts as system_instruction, and the visitor’s question as input. Because Google applies a system instruction only to the interaction it arrives with, the stored history holds just the questions and answers, the same lean history MxChat builds itself. Input stayed at about 27,000 tokens per conversation on Carbon and Flash, and roughly a quarter of it came back cached.
| Model | A. MxChat today | D. Stored turns, KB in system instruction | Difference |
|---|---|---|---|
| Gemini 4 Carbon, to 30 November | $52.66 | $47.96 | -9% |
| Gemini 4 Carbon, from 1 December ($4 / $20) | $105.32 | $95.92 | -9% |
| Gemini 3.8 Flash, to 31 December | $18.49 | $16.75 | -9% |
| Gemini 3.8 Flash, from 1 January 2027 ($1.50 / $7.50) | $36.97 | $33.50 | -9% |
| Gemini 4 Hydrogen | $44.65 | $58.44 | +31% |
Treat the 9% as a ceiling, not a promise. The two Carbon conversations in setup D cost $62.18 and $33.75 per 1,000; the difference was whether Google’s implicit cache already held the opening prompt. Run-to-run spread was larger than the gap between setups A and D on every model. What the test does show reliably is the other direction: putting the knowledge base in the stored input (setup C) never paid for itself.

What does not change: the 1 December price rise matters more
The layout question is worth a few percent. The model question is worth several times that. The same 1,000 six-message conversations in MxChat’s current layout cost $52.66 on Carbon today, $105.32 on Carbon from 1 December, $44.65 on Hydrogen and $18.49 on Gemini 3.8 Flash, and Flash was the fastest model in the test at 2.40 seconds a message. Flash’s own price doubles on 1 January 2027, and it still comes in at $36.97, about a third of December Carbon. We covered those changes in our test of every 1 December price change and in the individual tests of Gemini 4 Carbon, Gemini 4 Hydrogen and Gemini 3.8 Flash.
Storage: 55 days of your visitors’ chats, by default
The Interactions API keeps every interaction for 55 days on the paid tier and 1 day on the free tier. Turning that off with store=false also turns off previous_interaction_id, so you cannot have stored turns without storage. Paid projects can shorten the window to 7, 14 or 28 days in AI Studio, or delete an interaction through the API.
The less obvious change is on generateContent. Google’s changelog entry for 26 October 2026 says new paid-tier projects now store Generate Content requests by default (store=true), “matching the Interactions API.” Existing projects keep their previous setting. Gemini API logs are kept for 55 days by default. If you created the Google AI Studio project behind your chatbot’s API key on or after 26 October, your visitors’ messages and the knowledge-base excerpts sent with them may be stored there already, whichever API your plugin calls. The switch is in the Settings panel of the AI Studio Logs page, separately for Generate Content and Interactions. If your privacy policy describes what happens to chat messages, check that setting against it.
| Project and API | Stored by default? | Kept for | How to turn it off |
|---|---|---|---|
generateContent, paid project created before 26 Oct 2026 | No, unless enabled earlier in AI Studio | – | Nothing to do |
generateContent, paid project created on or after 26 Oct 2026 | Yes | 55 days (7, 14 or 28 configurable) | AI Studio Logs settings, or store=false per request |
| Interactions API, paid tier | Yes | 55 days | store=false, which disables previous_interaction_id |
| Interactions API, free tier | Yes | 1 day | As above |
When the Interactions API is the right call
Our test is a retrieval chatbot: short questions, a fresh block of excerpts per message, short answers. That is the worst case for stored turns, because most of each request is context you only need once. The trade looks different when the history is the expensive part and nothing bulky is attached per message:
- Agent loops with tool calls. A function call and its result can run to thousands of tokens, and the model needs all of them on the next step. Storing them once and reading them at the cached rate is the case Google designed this for.
- Long conversations without retrieval. A tutoring or writing assistant whose history grows with every message, and whose system prompt stays the same.
- Background jobs that use
background=true, which requires stored interactions.
For a knowledge-base chatbot the better rule is simpler: send the excerpts for the current question only, and keep them out of anything that will be stored and replayed. MxChat’s current generateContent layout already does the first part. If you build your own Gemini integration on the Interactions API, put per-message retrieval in system_instruction, as setup D did, not in input.
What to do on an MxChat site
- Nothing changes in the plugin. MxChat 3.2.28 calls
generateContentand sends earlier turns as plain question and answer text, which kept input near 4,100 to 4,800 tokens per message in our test. Your model choice is under the plugin’s settings, and setup guides are in the MxChat documentation. - Check where your Gemini key lives. If its AI Studio project was created on or after 26 October 2026, open the Logs settings and decide whether Generate Content logging should be on.
- Move off Carbon before 1 December if cost matters more to you than Carbon’s answers. In this test Gemini 3.8 Flash answered the same conversations for about a third of Carbon’s price and a fifth of its December price. The WooCommerce order lookup from our test conversation comes with MxChat Pro.
- Do not expect a saving from stored conversation state on its own. In this test the price per token and the thinking level moved the bill far more than where the history lived. Our Gemini 4 Neon test shows how much the thinking level alone can add.
FAQ
What is the Gemini Interactions API?
A Gemini API endpoint, POST /v1beta/interactions, that stores each request and response on Google’s side and returns an id. Sending that id as previous_interaction_id on the next request continues the conversation without resending the earlier turns. It runs the same models as generateContent, including Gemini 4 Carbon, Hydrogen and Neon and Gemini 3.8 Flash.
Is the Interactions API cheaper than generateContent?
The per-token prices are the same. Whether your bill drops depends on what is in the stored history. Earlier turns are still billed as input on every message; they are just likely to be billed at the cached rate. In our six-message chatbot test the stored-turn setup cost $55.93 per 1,000 conversations on Gemini 4 Carbon against $52.66 for the plugin’s resend layout.
Does previous_interaction_id mean earlier turns are free?
No. Google bills the stored conversation again as input tokens on every message. In 27 of 30 follow-up messages we tested, the whole previous interaction was billed at the cached rate, a tenth to a twentieth of the normal input price depending on the model.
How long does Google keep Interactions API conversations?
55 days on the paid tier and 1 day on the free tier, according to Google’s Interactions documentation. Paid projects can set 7, 14, 28 or 55 days in AI Studio, or delete an interaction through the API. Setting store=false stops storage but also disables previous_interaction_id.
Does generateContent store my requests now?
For paid-tier projects created on or after 26 October 2026, yes by default, according to Google’s changelog. Older projects keep their previous setting. You can turn it off per request with store=false or for the project in the AI Studio Logs settings.
Is the Interactions API slower?
Slightly, in our test. Median time to a complete answer was 0.6 to 1.0 seconds longer than generateContent on all three models: 5.90 against 5.00 seconds on Carbon, 4.21 against 3.59 on Hydrogen and 3.12 against 2.40 on 3.8 Flash.
Does MxChat use the Interactions API?
No. MxChat 3.2.28 sends Gemini chat requests to generateContent, with the system prompt and the current question’s knowledge-base excerpts in the first turn and earlier messages as plain text. Our test found that layout within a few percent of the cheapest option on Carbon and Flash.
Which Gemini model is cheapest for a WordPress chatbot right now?
Of the three we tested, Gemini 3.8 Flash: $18.49 per 1,000 six-message conversations, and the fastest at 2.40 seconds a message. It doubles to $1.50 / $7.50 per million tokens on 1 January 2027. Gemini 4 Carbon doubles to $4 / $20 on 1 December 2026.