At the end of the month I'd open the billing page and notice the API line had crept up a little. Running wallpaper, healing, and manifestation apps on my own for years, I've had a few mornings like that. Each request costs next to nothing, but the count keeps stacking up until it isn't nothing anymore.
Working solo, every dollar and every hour of maintenance counts — that was my starting motivation for trying Gemini API.
So I launched a new app, separate from the existing ones, built on Gemini API as its primary backend from day one. Three months later, I want to write down what went as expected and what surprised me.
If you're an indie developer on the fence about integrating Gemini API into your own project, I hope this helps.
Why I Switched
I was previously running similar functionality on GPT-4o Mini. The use cases were two: auto-generating "today's message" content inside the app, and producing personalized replies to short user text inputs. At a few tens of thousands of requests per month, I was paying roughly $4–6/month.
Three things pushed me toward Gemini:
Generous free tier. When I tested it, Gemini 2.5 Flash offered 1,500 RPD (requests per day) and 10 RPM on the free tier. For a small indie launch, being able to run in production without paying anything at all was a compelling starting point. Those numbers are from the time I tested, though, and limits get revised — check the official rate-limit page before you build on them.
Wide context window. My manifestation apps benefit from referencing a user's recent history when generating replies. With Gemini 2.5 Pro's one-million-token context, I stopped thinking about truncation and compression entirely — it just fits.
Infrastructure trust. When an app scales, you need confidence the API will still be there. So far, at tens of thousands of calls a month, I haven't hit a reliability problem I'd call meaningful.
What the Costs Actually Looked Like
Numbers are the most honest metric, so here's the real data.
Over three months, my app averaged 8,000–12,000 API calls per month. Running that through Gemini 2.5 Flash:
10,000 requests × 500 tokens avg = 5M tokens/month
Flash pricing (input $0.075/1M, output $0.30/1M):
Input cost: $0.375
Output cost (avg 300 tokens out): $0.90
Total: ~$1.28/month
One month I crossed the free tier limit and paid about $1.50. The other two months were free.
Compared to GPT-4o Mini, I'm paying roughly one-third to one-quarter of what I was paying — assuming equivalent quality, which I'll get into below. Prices change too, so read the arithmetic above as one example built on the price list I had at the time.
Quality and Accuracy: The Honest Take
Quality varied by use case.
Content generation (daily messages): For short uplifting messages and affirmation text, Gemini 2.5 Flash and GPT-4o Mini were functionally indistinguishable. Both toggle between "sounds human" and "clearly AI-patterned" depending on prompt design, not on which model you pick.
Replies to user input: For responding to short inputs (20–50 characters), Gemini occasionally returned responses that felt over-explained — adding reasons and context when the user just wanted a short, direct reply. For Japanese nuance work requiring specific emotional register, I still reach for GPT-4o.
Japanese language quality: Overall, Gemini 2.5 Flash handles Japanese well. Mixing polite and casual forms, the classic Japanese AI pitfall, is controllable through the system prompt. I had expected Gemini to feel more English-native, but that hasn't been my experience in practice.
Latency: Real Numbers
For mobile apps, latency matters more than cost. A slow response feels like a broken app, and that shows up in store reviews.
Median (p50) and 95th percentile (p95) from my production logs:
- Gemini 2.5 Flash (non-streaming): p50 ≈ 900ms, p95 ≈ 2,800ms
- Gemini 2.5 Flash (streaming): first token p50 ≈ 400ms
- GPT-4o Mini (non-streaming): p50 ≈ 700ms, p95 ≈ 2,200ms
Flash runs slightly slower. However, switching to streaming mode nearly eliminated the perceived delay — users see text appearing almost immediately.
I originally wrote this with the old google-generativeai SDK; the current one is google-genai, so here is the same snippet rewritten for it.
from google import genai
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")
# Streaming: first token arrives fast, so the UI feels responsive
for chunk in client.models.generate_content_stream(
model="gemini-2.5-flash",
contents="Give me one short, uplifting phrase to start the morning.",
):
print(chunk.text, end="", flush=True)For mobile chat UIs, streaming mode is the right default. The user knows something is happening within 400ms, which is well within the threshold where waiting starts to feel like a bug.
How I Split Work Across Gemini, Claude, and GPT-4o
Across my apps right now I'm running three APIs for different jobs:
Gemini 2.5 Flash: Short content generation, affirmation text, brief user replies. High-volume, cost-sensitive paths.
Claude Sonnet 4.5: Design decisions, prompt iteration, code review. When I need to think through a problem in dialogue, Claude tends to fit how I reason.
GPT-4o: Edge cases requiring precise Japanese emotional register. Low volume but meaningful quality difference here.
I can't honestly say Gemini is the best model for everything. The more useful frame is: what does each model do well, and does that match what I need?
I used to obsess over rankings. I'd build side-by-side comparison tables and watch to see which model won — and it didn't go well, because every new release just meant redoing the comparison.
Now, before picking a model, I decide which paths in my app are cost-bound and which are quality-bound. Compare paths, not models. Once that split is clear, swapping in a newer model later is a one-line change.
What Surprised Me
Good surprises:
- The free tier lasted longer than I expected in production
- Google AI Studio made prompt iteration genuinely easy, even from my phone
- Context caching made the cost of repeated system prompts essentially zero
Unexpected friction:
- RPM limits hit sooner than I anticipated. Even on the free tier, burst-heavy usage patterns run into the rate cap quickly
- Gemini 2.5 Pro and Flash differ slightly in JSON mode reliability. Pro consistently returns well-formed structured output; Flash occasionally drifts off-format
- The Python SDK updates frequently, and small breaking changes slip in. I hadn't pinned my dependencies, and one morning the app simply stopped working.
That last one made my stomach drop. Pin the version you actually tested, rather than a range:
# requirements.txt
google-genai==<the version you tested> # pin the tested version, not a rangeHandling the Free-Tier RPM Limit
Let me expand on the "RPM wall" I listed as a surprise, since the fix is worth sharing. Gemini 2.5 Flash's free tier allowed 10 requests per minute (RPM) when I measured. Even with plenty of headroom on the 1,500 requests-per-day (RPD) cap, if user activity clusters into a specific window, this per-minute limit bites first.
My app sees a traffic spike between 7–8am, and during that window I started getting sporadic 429 (RESOURCE_EXHAUSTED) errors. At first I retried immediately on failure, which only produced more 429s. Switching to exponential backoff resolved it almost entirely.
import time
import random
from google import genai
from google.genai import errors
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")
def generate_with_backoff(prompt, max_retries=5):
for attempt in range(max_retries):
try:
return client.models.generate_content(
model="gemini-2.5-flash", contents=prompt
)
except errors.APIError as e:
if e.code != 429:
raise # waiting won't fix anything but 429, so pass it up
# Grow the delay exponentially and add random jitter
# so concurrent retries don't collide.
time.sleep((2 ** attempt) + random.uniform(0, 1))
raise RuntimeError("Retry limit reached")The key is distinguishing 429 from every other error. Retrying auth failures or invalid-argument errors just wastes time — catch only the 429 and wait. That single distinction was what kept me from burning through the free tier.
Going one step further, you can queue generations and cap your own send rate at around 8 per minute. Leaving a little slack below the ceiling holds up better under sudden traffic than pushing right against the limit.
Where I Go From Here
Three months in, my conclusion is that Gemini API was a sound choice for an indie app's small-scale start. Up to around 10,000 requests per month, you can run production-quality generative AI features almost for free while you iterate.
That freedom to experiment without watching a cost meter is what I value most at this stage of a new app — it leaves room to fail and start over. Next I plan to combine Gemini 2.5 Pro's Thinking Mode with context caching and see how far response quality goes without a real jump in cost.
If you want a place to start, split your own app's paths into cost-bound and quality-bound. That's where I'd begin.