Every Free Tier Is a Loan, and Someone Decides the Collateral
Every free AI tier is a loan against a future price. You are not getting something for nothing. You are borrowing compute now against a bill the provider gets to write later, and that bill comes in one of three currencies: your data, your architecture, or your time when they yank the whole thing.
Two other posts on this site will show you how to build a working stack on free tiers and how to stretch one further than it wants to go. Both are worth reading. Neither one tells you what you actually signed up for, which is the point of this one.
The Three Kinds of Collateral
Your prompts, as training data
Some free tiers say outright that your inputs and outputs may get reviewed by humans and folded into future model training. Google’s Gemini API terms are refreshingly blunt about this: on the free tier, Google uses the content you submit “to provide, improve, and develop” its products, and human reviewers may read and annotate your API input and output. Flip to the paid tier of the exact same API and that clause disappears. Google states plainly that it does not use your prompts or responses to improve its products once you are paying for them.
OpenAI runs a version of the same trade. Automatic free trial credits for new API accounts went away in 2025, but at the time of writing OpenAI still offers a free daily token allowance on GPT-5-family and mini models if you opt into data sharing. Skip the opt-in and pay for tokens instead, and your traffic is not used for training. Same company, same models, two different privacy postures depending on which button you clicked at signup.
Neither company is hiding this. It is right there in the terms. The point is that “free” and “private” are separate knobs, and a provider offering both usually charges for the second one with your data on the free setting.
Lock-in
The second kind of collateral is not your data at all. It is your architecture. A free tier that only works through a proprietary SDK, a vendor-specific agent framework, or a file format nothing else reads is free precisely because it is a funnel. Every hour you spend wiring your app to that SDK is an hour of switching cost you are handing over for nothing, and switching cost is the whole business model. What the tier subsidizes is the cost of making you hard to leave.
You will not find this one in a terms-of-service page, because it is a design choice rather than a legal commitment. Check it by asking a blunt question before you integrate anything: if this became a paid API tomorrow, could I swap the endpoint and keep my code? If the honest answer involves rewriting your agent logic, you already paid the toll, you just did not notice the invoice.
Nothing, for now
The third kind is the one nobody warns you about because there is genuinely nothing to warn about yet. Plenty of free tiers really are loss leaders in a land grab, funded by venture money chasing market share with no data harvesting and no lock-in trick. Calling that a scam is unfair. Calling it permanent is naive, and the provider is under no obligation to tell you when temporary ends. Land grabs have expiry dates. You just don’t get to see the calendar.
Read the Terms, Specifically
You do not need a lawyer for this, you need one comparison. Pull up the data policy for the free tier and the data policy for the paid tier of the same provider, side by side, and look for a difference. If the paid tier explicitly excludes your content from training and the free tier does not make that promise, that gap is the tell. It means the company has already priced your data into the free product, and the fact that they bothered writing a better policy for paying customers proves they know exactly what they are doing with the worse one.
If the two tiers use identical language, that is worth something too. It usually means the free tier is the loss-leader kind of free rather than the data-harvesting kind, at least for now.
The Pattern of the Pull
The shape repeats often enough that you can set a clock by it. A free tier launches generous, because generous gets attention and attention gets funding rounds. Usage grows past what the provider modeled. Rate limits that used to feel invisible start showing up in error logs. Then one of three things happens: a credit system replaces the flat monthly allowance, the specific small model your workflow depended on gets folded into an opaque “auto-select” router you no longer control, or the whole tier goes paid with two weeks of notice in a changelog post you didn’t subscribe to.
My Own Free Lunch Got a Bill
I had a cheap-model-as-workhorse setup built around GitHub Copilot’s free access to smaller models, good enough for scaffolding, refactors, and grunt-work completions I did not want to burn a frontier model’s context on. It worked because Copilot’s free and lower tiers let you point at those smaller models directly.
On June 1, 2026, GitHub replaced premium request units with a token-metered “AI Credits” system, and the old fallback behavior, where you dropped to a cheaper model once you burned your allowance, went away entirely. A few weeks later, GitHub restricted free and Student plans to a single “Auto” model-selection mode, so you can no longer manually pin your workflow to a specific small model. The credits that ship with each plan reset every month with no rollover, so there is no way to bank a quiet month against a busy one either.
None of this was hidden. GitHub wrote a blog post and a changelog entry, like they were supposed to. But a setup that worked because I could reliably reach a specific cheap model on my own terms stopped working the day that control got taken away, and it stopped in one release, not gradually. That is the rug pull. It rarely arrives as a cancellation notice. It arrives as a feature deprecation with a reasonable-sounding name.
How to Build So the Pull Doesn’t Hurt
You cannot stop providers from doing this, it is their product and their balance sheet. You can build so that when it happens, it costs you an afternoon instead of a rewrite.
Talk to every provider through an OpenAI-compatible endpoint wherever one exists, even the ones that would rather sell you their own SDK. Put a router like LiteLLM or OpenRouter in front of your model calls so a provider swap is a config line, not a code review. Never let a free tier’s proprietary SDK, agent framework, or file format touch your actual application code, keep it behind an interface you control, so the day that tier changes shape you are editing an adapter instead of your business logic. And keep something local that can run your critical path, even badly, on hardware you own. A slow local model that answers is worth more than a fast cloud model that stops answering.
Use the free tiers. Take everything they give you while they are giving it. Just design every integration as though the specific one you are using disappears next quarter, because on a long enough timeline, it will.
