Free LLM API options in 2026: what is still free, the real limits, and how to feed it Twitter (X) data

- Still free: Gemini API free tier, OpenRouter
:freemodels, Groq free plan, Cloudflare Workers AI (10,000 Neurons a day). Trial only: Cohere (1,000 calls a month), Cerebras ($5 for 30 days). - Gone from older lists: Mistral's Free mode "doesn't include API access", and GitHub Models was retired on July 30, 2026.
- OpenRouter free caps: 20 requests a minute; 50 a day under 10 credits purchased, 1,000 a day at 10 or more. Its public model list showed 14
:freeids when we checked. - Gemini's trade: free-tier content is used to improve Google products; paid-tier content is not. Limits apply per project, not per key.
- X data is small: median post 226 characters (about 56 tokens); about 79 compact post records fit in an 8K prompt, so one free request summarizes a day of most brand accounts.
- Getting the posts: TwitterAPI.io bills $0.15 per 1,000 tweets returned, against $0.005 per post read on the official X API rate card (about 33x), and new accounts get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days).
Most "free LLM API" lists are copied from each other, and free tiers move faster than the lists. While building this page we opened every provider's own pricing or rate-limit page and found two of the usual entries no longer true: Mistral's documentation now says its Free mode does not include API access, and GitHub's documentation says GitHub Models was retired on July 30, 2026. Everything below comes from the provider's page itself; when a page does not publish a number, we say so instead of quoting a third-party figure.
This page is the cross-provider map. For a single provider in depth, see our pages on Google AI Studio's free tier limits and on the OpenRouter API; for paid keys, our guides to getting a Claude API key and an OpenAI API key. The one section specific to us covers feeding X (Twitter) posts into a free model, with a measured answer to how many posts fit in a free request.
About 79 posts per 8,000-token prompt: a compact post record is a median of about 88 tokens across 988 posts from 10 AI-provider accounts (collected in 2026).
Which free LLM APIs are still free (provider by provider)
A free LLM API comes in three shapes: a standing free tier with rate limits (Gemini, OpenRouter :free, Groq, Cloudflare Workers AI), a trial that ends after a call budget or a date (Cohere's trial key, Cerebras' $5 credits), and monthly credits on a paid plan (Hugging Face PRO). The table lists what each provider's own page said when we checked.
Read the catch column first. It decides whether a tier fits your project more than the limits do: Gemini's free tier uses your content to improve Google's products, OpenRouter's daily cap depends on whether you have ever bought 10 credits, Cohere's trial key is for evaluation, and Cerebras' credits expire after 30 days.
Google Gemini API free tier: per project, data used for training
Google's pricing page (now served at aistudio.google.com/docs/pricing, redirected from ai.google.dev) marks each model's free tier as Free of charge or Not available. Free of charge when we checked: Gemini 4 Hydrogen, Gemini 3.8 Flash, Gemini 3.6 Flash, Gemini 3.5 Flash-Lite, Gemini 3.1 Flash-Lite, Gemini 3 Flash Preview, Gemini 2.5 Pro, Gemini 2.5 Flash, Gemini 2.5 Flash-Lite and both embedding models. Not available on the free tier: Gemini 4 Carbon, Gemini 4 Argon, Gemini 3.1 Pro Preview and the image models.
Limits. The rate-limit page defines three dimensions, requests per minute (RPM), input tokens per minute (TPM) and requests per day (RPD); exceeding any one triggers a 429. Limits apply per project, not per API key, so creating more keys in one project does not add quota, and RPD resets at midnight Pacific time. The page itself prints per-model numbers only for a few models and points to the rate-limit view in AI Studio for the rest, which updates as your tier changes.
Data use. The free-tier card says "Content used to improve our products"; the paid tier says content is not. Do not send customer data or anything under an NDA through the free tier. Our Google AI Studio free-tier page covers the per-model numbers in more depth.
OpenRouter :free models: 20 a minute, 50 or 1,000 a day
OpenRouter routes one OpenAI-compatible endpoint (https://openrouter.ai/api/v1/chat/completions) to hundreds of models. Its limits page sets the rules for model ids that end in :free: 20 requests per minute regardless of credits, and 50 requests per day if you have bought fewer than 10 credits in total, 1,000 per day once you have bought at least 10. A negative credit balance can return HTTP 402 even on free models.
How many free models. OpenRouter's X bio advertises "50+ free" models, but its public model list (the models endpoint of its API, readable without a key) returned 471 models when we fetched it this year, of which 14 had ids ending in :free, plus the openrouter/free router. The free ids included google/gemma-4-31b-it:free, google/gemma-4-26b-a4b-it:free, several NVIDIA Nemotron models and cohere/north-mini-code:free, with context windows from 256,000 to about 1 million tokens. The list changes often, so read it from the endpoint instead of hard-coding ids.
Our OpenRouter API page covers keys, routing and paid models; the code at the end of this page uses an OpenRouter free model.
Groq, Cloudflare Workers AI, Cohere and Cerebras
Groq. Rate limits apply at the organization level and come in RPM, RPD, TPM and TPD (plus audio seconds for Whisper). The docs page offers "Free Plan Limits" and "Developer Plan Limits" tabs; the table it serves carries the note that the limits shown are the base limits for the Developer plan, listing openai/gpt-oss-120b and openai/gpt-oss-20b at 30 RPM, 1K RPD, 8K TPM and 200K TPD. Your organization's exact free-plan limits are on the console's limits page. Every response carries x-ratelimit-* headers (requests count against RPD, tokens against TPM), and a 429 adds retry-after in seconds.
Cloudflare Workers AI. Both Workers Free and Workers Paid include "10,000 Neurons per day at no charge", reset at 00:00 UTC. Free accounts stop there; Paid accounts pay $0.011 per 1,000 Neurons above it. Neurons map to tokens per model: @cf/meta/llama-3.1-8b-instruct-fp8-fast lists $0.045 per million input tokens and $0.384 per million output tokens.
Cohere. A trial (evaluation) key allows 20 chat requests a minute, 2,000 embedding inputs a minute and 10 rerank requests a minute, and "Trial keys ... are limited to 1,000 API calls a month". Production keys are paid.
Cerebras. New accounts get a $5 Free Trial after adding a verified payment method; the credits expire 30 days after they are granted and the page says there is no permanently free tier. During the trial gpt-oss-120b allows 5 requests a minute and 1M tokens a day.
Free tiers that closed: Mistral, GitHub Models, Hugging Face
Mistral. Many lists still describe a free "Experiment" API plan. Mistral's help-center articles about it now return 404, and its admin documentation says the Free mode "includes a monthly usage budget for trying Vibe and Studio. It doesn't include API access. Creating API keys and using the API require billing activation and pay-as-you-go."
GitHub Models. GitHub's documentation says GitHub Models was retired as of July 30, 2026: the playground, model catalog, inference API and bring-your-own-key are no longer available, and it points to Azure AI Foundry and GitHub Copilot instead.
Hugging Face. The Inference Providers pricing page lists no monthly credits for Free users (they must buy credits), $2.00 a month for PRO users and $2.00 per seat for Team or Enterprise organizations.
Why lists go stale. In our sample of 705 original posts from these providers' own X accounts, only 22 mentioned free access and 9 mentioned limits or quotas, and none announced a deprecation. Free-tier changes land in docs and changelogs rather than on X, which is why this page checks the docs.
How much X (Twitter) data fits in a free LLM request
We pulled the recent timelines of 10 AI-provider accounts on X (988 posts, 705 of them original rather than reposts, collected in 2026) and measured the text. The median post is 226 characters, about 56 tokens; the 90th percentile is 401 characters, about 100 tokens; the longest was 1,440 characters. A compact JSON record per post (text, author, time, likes, views) is a median of about 88 tokens.
What that means for a free model. With 1,000 tokens reserved for instructions, an 8,000-token prompt holds about 79 posts at median size, or 53 if every post were at the 90th percentile. That fits inside Groq's 8K TPM table value in one request per minute and far inside the 256,000-token-plus context of OpenRouter's free models.
Of the original posts, 207 ran 280 to 499 characters and 31 ran past 500, so do not assume the old 280-character ceiling when you size a batch.

Posts a day each free cap can take
Dividing each published cap by our median record size gives the number of X posts a day a free tier could take as input (output tokens and retries come on top). The 10 accounts in our sample posted about 14.8 times a day combined, roughly 1,301 tokens of compact records, so even the smallest cap below covers a brand-monitoring digest many times over. The binding constraint for X data is usually requests per day, not tokens.
Choosing a tier for X data. For a daily digest of a few accounts or one keyword, any of these works, and Gemini's or OpenRouter's free tier is enough. For classifying every post in a busy keyword stream, the request caps bind: batch about 70 to 80 posts into each LLM request instead of sending one LLM request per post.

Feeding X data into a free model: getting the posts
A free model is only half of an X digest; you still need the posts. TwitterAPI.io returns them as JSON over REST with an X-API-Key header, no X account needed for reads. /twitter/tweet/advanced_search takes the same query operators as X search (from:, lang:en, min_faves:10, since_time:) and returns tweets[] with has_next_page and next_cursor; /twitter/user/last_tweets returns an account's recent posts under data.tweets[].
Cost. Tweet endpoints bill 15 credits per tweet returned, $0.15 per 1,000 tweets, pay only for the data returned; a search that finds nothing costs the 15-credit minimum ($0.00015). On the official X API pay-per-usage rate card a post read is $0.005, $5 per 1,000, about 33x more. Our study read 988 posts for about $0.15.
Free start. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days). At $0.15 per 1,000 tweets that is enough to test a digest pipeline on several thousand posts before paying anything, and purchased credits never expire. Rate limits are 0.2 requests a second before the first payment and 20 once paid; see /pricing for plans.
Or skip the code. If your model runs in an MCP client (Claude, Cursor and others), our MCP server at https://mcp.twitterapi.io/mcp with an Authorization: Bearer <key> header exposes X search and user lookups as tools; our MCP server page lists them.
# one page of posts (up to 20) for a query; costs $0.003 for a full page
curl -s "https://api.twitterapi.io/twitter/tweet/advanced_search?query=%22free%20tier%22%20lang%3Aen&queryType=Latest" \
-H "X-API-Key: $TWITTERAPI_IO_API_KEY" | python3 -m json.tool | head -40How we collected this
Question. How long are X posts in characters and estimated tokens, how many fit in a free LLM request, and how often do the providers that run free tiers post about free access, limits or deprecations?
Accounts. The official X accounts of 10 organizations with LLM APIs: @GoogleAIStudio, @OpenRouter, @MistralAI, @CloudflareDev, @github, @huggingface, @cerebras, @togethercompute, @cohere and @NVIDIAAIDev. We planned @GroqInc and @OpenRouterAI; the first returned a profile with no posts and the second does not exist, so we used @OpenRouter and @NVIDIAAIDev.
Window and sample. Up to the 100 most recent timeline posts per account (replies excluded), 988 posts in all, collected in 2026. Per-account windows run from about a month (@OpenRouter, @CloudflareDev) to well over a year (@MistralAI posted about 0.16 times a day). 56 API requests in total, about $0.15.
Method. Tokens are estimated as characters divided by 4, a common approximation for English text; real tokenizers differ by model and language, and non-English text usually costs more tokens per character. Free-tier capacity divides each provider's published cap by our median record size and counts input only. Mentions are keyword matches ("free", "rate limit", "quota", "deprecat", "retire"), not a manual reading.
What this cannot show. Brand accounts write short, edited posts; a keyword stream of replies or long-form posts will have a different length mix. The free-tier limits are what each page said when we checked and can change at any time. Privacy: organization accounts only, aggregates only, no analysis of reposted or quoted authors.
"""free_llm_x_digest.py - pull recent X (Twitter) posts for a query and summarize them
with a free LLM API model (OpenRouter :free model, OpenAI-compatible chat endpoint).
pip install requests
export TWITTERAPI_IO_API_KEY=... # twitterapi.io dashboard
export OPENROUTER_API_KEY=... # openrouter.ai account (free models need no credits)
export FREE_MODEL=google/gemma-4-31b-it:free # any model id ending in :free on openrouter.ai/models
"""
import json
import os
import time
import requests
BASE = "https://api.twitterapi.io"
X_HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_API_KEY"]}
LLM_URL = "https://openrouter.ai/api/v1/chat/completions"
LLM_HEADERS = {"Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}"}
MODEL = os.environ.get("FREE_MODEL", "google/gemma-4-31b-it:free")
QUERY = os.environ.get("X_QUERY", '"free tier" (LLM OR API) lang:en -filter:replies min_faves:10')
PROMPT_TOKENS = 7000 # leave ~1,000 of an 8K window for instructions
MAX_PAGES = 5 # 5 pages x 20 posts = 100 posts, $0.015 at $0.15 per 1,000 tweets
def fetch_posts(query, max_pages=MAX_PAGES):
posts, cursor = [], ""
for _ in range(max_pages):
r = requests.get(f"{BASE}/twitter/tweet/advanced_search",
params={"query": query, "queryType": "Latest", "cursor": cursor},
headers=X_HEADERS, timeout=30)
r.raise_for_status()
body = r.json()
for t in body.get("tweets", []):
posts.append({
"text": t["text"],
"author": t["author"]["userName"],
"createdAt": t["createdAt"],
"likeCount": t.get("likeCount", 0),
"viewCount": t.get("viewCount", 0),
})
if not body.get("has_next_page"):
break
cursor = body.get("next_cursor", "")
return posts
def est_tokens(s):
return max(1, len(s) // 4) # rough: about 4 characters per token for English
def batches(posts, budget=PROMPT_TOKENS):
batch, used = [], 0
for p in posts:
line = json.dumps(p, ensure_ascii=False)
n = est_tokens(line)
if batch and used + n > budget:
yield batch
batch, used = [], 0
batch.append(line)
used += n
if batch:
yield batch
def summarize(lines):
msg = ("Below are recent X posts, one JSON object per line. Summarize the main themes in 5 bullet "
"points and name the 3 most-liked posts by author.\n\n" + "\n".join(lines))
for attempt in range(5):
r = requests.post(LLM_URL, headers=LLM_HEADERS, timeout=120,
json={"model": MODEL, "messages": [{"role": "user", "content": msg}]})
if r.status_code == 429: # free models: 20 requests/minute, 50 or 1,000 a day
time.sleep(int(r.headers.get("retry-after", 10 * (attempt + 1))))
continue
r.raise_for_status()
return r.json()["choices"][0]["message"]["content"]
raise RuntimeError("free model still rate-limited after 5 tries")
if __name__ == "__main__":
posts = fetch_posts(QUERY)
print(f"fetched {len(posts)} posts")
for i, lines in enumerate(batches(posts), 1):
print(f"--- batch {i}: {len(lines)} posts ---")
print(summarize(lines))
Researching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.
Questions readers ask
Is there a completely free LLM API?
Yes, with limits. Google's Gemini API has a free tier on its Flash, Flash-Lite and Gemini 2.5 Pro models, OpenRouter offers models whose ids end in :free (20 requests a minute, 50 a day), Groq has a free plan with organization-level limits, and Cloudflare Workers AI includes 10,000 Neurons a day at no charge. Cohere's trial key (1,000 calls a month) and Cerebras' $5 trial credits are trials rather than standing free tiers.
Does Mistral still have a free API tier?
Not according to Mistral's current documentation. It says the Free mode includes a monthly budget for trying Vibe and Studio but "doesn't include API access", and that creating API keys and using the API require billing activation and pay-as-you-go. The help-center articles about the old Experiment plan now return 404.
Is GitHub Models still free?
No. GitHub's documentation says GitHub Models was retired as of July 30, 2026; the playground, model catalog, inference API and bring-your-own-key are no longer available. GitHub points to Azure AI Foundry and GitHub Copilot instead.
How many requests a day do OpenRouter free models allow?
OpenRouter's limits page says 50 requests a day if you have bought fewer than 10 credits in total and 1,000 a day once you have bought at least 10, with 20 requests a minute either way. A negative balance can return HTTP 402 even on free models.
Does the Gemini API free tier use my data?
Google's pricing page lists "Content used to improve our products" for the free tier and content not used for the paid tier. Keep customer data and anything confidential on the paid tier.
Are Gemini free tier limits per API key?
No. Google's rate-limit page says limits apply per project, not per API key, and requests-per-day quotas reset at midnight Pacific time. Creating extra keys in the same project does not add quota.
How many tweets can I summarize with a free LLM API?
In our sample a compact post record (text, author, time, likes, views) was a median of about 88 tokens, so about 79 posts fit in an 8,000-token prompt with room for instructions. At that batch size OpenRouter's 50 free requests a day cover about 3,950 posts, and Groq's 200K tokens a day (table value) about 2,272.
Where do I get the X posts to feed a free model?
The official X API charges $0.005 per post read on its pay-per-usage rate card. TwitterAPI.io charges $0.15 per 1,000 tweets returned, with no X account needed for reads, and new accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days).
Continue
- Google Gemini API pricing: which models are free of charge on the free tier, data-use terms
- Google Gemini API rate limits: RPM / TPM / RPD, per project, usage tiers
- OpenRouter docs: limits for :free models (20/min, 50 or 1,000/day)
- Groq docs: rate limits, headers and 429 handling
- Cloudflare Workers AI pricing: 10,000 Neurons a day free
- GitHub docs: GitHub Models retirement notice
- X (Twitter) API hub: endpoints, pricing and guides
- OpenRouter API guide: keys, routing and free models
- Google AI Studio free tier limits in depth
- How to get a Claude API key
- How to get an OpenAI API key
- How to build an AI agent that reads live X data
- Using Gemini with the Twitter (X) API
- TwitterAPI.io MCP server and its X tools
- TwitterAPI.io pricing: $0.15 per 1,000 tweets
- 01RAG vs MCP: Retrieval vs Live Tools, Measured on Twitter (X) Data
- 02Clay Pricing in 2026: Plans, Data Credits, Actions and the Cost of a Twitter (X) Column
- 03MCP Inspector: How to Test and Debug an MCP Server, Tested on a Live X Data Server
- 04What Is an API Key? Meaning, a Real Request, and How to Keep One Safe
- 05Twitter (X) Error 400: What "Bad Request" Means and How to Fix It
- 06Mass Delete Tweets — Bulk API Workflow + Free Tool Options
- 07Twitter (X) Analytics Free — A Tier Comparison
- 08Free Twitter Analytics — A Working Setup at $0/month
Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API keyAlready building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.