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

By TwitterAPI.io Team•13 min read
Grid of eight free LLM API offers as their own documentation describes them. Green free tiers: Google Gemini API (free tier on Flash, Flash-Lite and 2.5 Pro, limits per project, daily quota resets midnight Pacific), OpenRouter :free (14 free model ids, 20 requests a minute, 50 a day or 1,000 after 10 credits), Groq (organization-level limits, gpt-oss-120b 30 RPM, 1K RPD, 200K tokens a day), Cloudflare Workers AI (10,000 Neurons a day, reset 00:00 UTC). Blue trials: Cohere trial key (20 chat requests a minute, 1,000 calls a month) and Cerebras ($5 credits for 30 days, card required, no permanently free tier). Red: Mistral (Free mode does not include API access) and GitHub Models (retired July 30, 2026). Footer: study of 988 posts from 10 provider accounts on X, collected in 2026; a compact post record is about 88 tokens, so about 79 posts fit in one 8K prompt.
Free LLM API offers as each provider's own page describes them; footer numbers come from the study on this page (collected in 2026).
TL;DR
  • Still free: Gemini API free tier, OpenRouter :free models, 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 :free ids 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.

X posts that fit in one free LLM 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).

01 — Section

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.

ProviderFree offer (per its own page)Published limitsCatch
Google Gemini APIFree tier on Gemini 3.8 Flash, 3.6 Flash, 3.5 / 3.1 Flash-Lite, 2.5 Pro, 2.5 Flash, embeddingsPer project; RPD resets at midnight Pacific; per-model numbers shown in AI StudioFree-tier content is used to improve Google products; Gemini 4 Carbon / Argon and 3.1 Pro Preview not on Free
OpenRouter14 model ids ending in :free (plus the openrouter/free router)20 requests/min; 50 requests/day, 1,000/day once you have bought 10+ creditsA negative balance can return 402 even on free models
GroqFree plan, organization-level limitsTable served on the docs (labeled Developer-plan base limits): openai/gpt-oss-120b 30 RPM, 1K RPD, 8K TPM, 200K TPDYour plan's exact limits are on the console limits page
Cloudflare Workers AI10,000 Neurons a day on Workers Free and PaidResets 00:00 UTC; Paid bills $0.011 / 1,000 Neurons above itWorkers Free cannot go past the allowance
CohereTrial (evaluation) keyChat 20 req/min; 1,000 API calls a monthEvaluation use; production keys are paid
Cerebras$5 Free Trial credits, card required, 30 daysgpt-oss-120b 5 RPM, 1M tokens/dayStates there is no permanently free tier
Hugging FaceNo monthly credits for Free usersPRO $2.00 of credits a monthFree users must buy credits
MistralFree mode for Vibe and StudioFree mode does not include API accessAPI needs billing activation, pay-as-you-go
GitHub ModelsRetired July 30, 2026Inference API no longer availableMoved users to Azure AI Foundry / Copilot

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.

02 — Section

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.

03 — Section

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.

04 — Section

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.

05 — Section

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.

06 — Section

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.

Post sizeCharactersEstimated tokens
Median text22656
90th percentile text401100
Longest text1,440360
Median compact JSON recordnot applicable88

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.

Bar chart of X post text length for 705 original posts from 10 AI-provider accounts, collected in 2026: 153 under 100 characters, 153 at 100-199, 161 at 200-279, 207 at 280-499, 28 at 500-999 and 3 at 1,000 or more. Side panel: median 226 characters (about 56 tokens), 90th percentile 401 (about 100 tokens), longest 1,440 (about 360 tokens), compact JSON record median about 88 tokens, about 79 posts fit in an 8K prompt.
Post length in the sample, collected in 2026. Tokens estimated as characters divided by 4.
07 — Section

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.

Free cap (from the provider's page)UnitPosts a day it can take as input
Groq gpt-oss-120b (table labeled Developer base limits)200K tokens/day2,272
Cerebras gpt-oss-120b Free Trial1M tokens/day11,363
OpenRouter :free, under 10 credits bought50 requests/day3,950
OpenRouter :free, 10+ credits bought1,000 requests/day79,000
Cohere trial key (spread over 30 days)1,000 calls/month2,633

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.

Horizontal log-scale bar chart of X posts per day each free LLM cap could take as input at about 79 posts per LLM request: OpenRouter :free with 10 or more credits bought, 1,000 requests a day, 79,000 posts; Cerebras trial, 1M tokens a day, 11,363 posts; OpenRouter :free under 10 credits, 50 requests a day, 3,950 posts; Cohere trial, 1,000 calls a month, 2,633 posts a day; Groq gpt-oss-120b, 200K tokens a day, 2,272 posts.
Input capacity per free cap, from each provider's published limit and the median post record in our study (collected in 2026).
08 — Section

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.

bash
# 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 -40
09 — Section

How 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.

AccountPosts sampledPosts a dayMedian length (chars)Posts mentioning free
@OpenRouter1003.2125812
@CloudflareDev1002.861951
@github1002.632104
@togethercompute1001.882771
@cohere1001.372170
@cerebras1001.082290
@huggingface940.581201
@GoogleAIStudio940.56760
@NVIDIAAIDev1000.512732
@MistralAI1000.162541

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.

python
"""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.

10 — Questions

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).

11 — Further reading

Continue

Sources & further reading
More from this series

Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.

Build it

Stop reading. Start building.

Starter credits cover real testing on real data. Google sign-in, no card, no application queue.

Get an API key

Already building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.