tashfeenahmed

Run Claude Code and the OpenAI SDK on free LLM tiers with FreeLLMAPI Almost every AI lab now has a free tier: a few million tokens a month, a few thousand requests a day. One tier on its own is a toy. Stacked together behind one endpoint, they are enough to run side projects, experiments and even a coding agent without a bill. That is the idea behind FreeLLMAPI. tashfeenahmed/freellmapi is a self-hosted server that aggregates the free tiers of 34 LLM providers behind a single OpenAI-compatible /v1 API. Per the README it stores your provider keys encrypted, routes each request to the best available model, falls over to the next provider when one is rate-limited, and tracks per-key usage so you stay under every free-tier cap. The README puts the stacked total at roughly 7.4 billion tokens a month across 635 free model endpoints. This post covers the install, connecting Claude Code, and calling it from Python. How the routing works You add keys for the providers you want (Google, Groq, Cerebras, Mistral, OpenRouter, Cloudflare, Cohere, NVIDIA, Hugging Face and more) and order them in a fallback chain. For each request the router picks the highest-priority model with a healthy key that is under all its rate limits, decrypts the key in memory and calls the provider. On a 429 or 5xx it cools that key down and retries the next model in your chain. A few details make it practical for agents: - More than chat completions. It serves /v1/responses (what Codex CLI needs), /v1/embeddings, image, speech and transcription endpoints, and /v1/models. - Anthropic Messages API. /v1/messages speaks Anthropic's wire format, so Claude Code and the Anthropic SDKs can run against the free pool. - Sticky sessions. A conversation stays on one model for 30 minutes, with an optional handoff note if a mid-chat switch does happen. - One token out. Your apps only ever see a single unified freellmapi- bearer key. Provider keys are AES-256-GCM encrypted in SQLite. Step 1: install With Docker, the one-liner sets up ~/freellmapi, generates an encryption key, pulls the image and starts the container: curl -fsSL https://freellmapi.co/install.sh | bash Read the script first if you prefer; the README links it. Re-running it keeps your .env and encryption key and updates the container. On Windows or macOS there is also a desktop tray app on the Releases page, which runs the router and dashboard locally with no account to set up. From source: npm install && npm run dev That gives you the server on port 3001 and the dashboard on 5173. Step 2: add keys and grab the unified key Open localhost, add provider keys on the Keys page, reorder the Fallback Chain, and copy the unified API key from the Keys page header. The Playground shows which provider served each test message, with model ID and latency, which is a quick way to confirm your keys work. Step 3: point Claude Code at it The README gives a setup command that reads your live catalog, backs up the existing config and merges into it: npx freellmapi setup-claude --url http://localhost:3001 --api-key <unified-key> Every generator supports --dry-run so you can see the change first. If you would rather keep credentials out of config files, npx freellmapi launch starts Claude Code against the router and launch-codex does the same for Codex. The supported list also covers Gemini CLI, Cursor, Cline, Roo Code, OpenCode, Aider, Goose, Crush, Zed and more. Step 4: call it from Python Any OpenAI client works. Set the base URL to your server: from openai import OpenAI client = OpenAI( base_url="http://localhost:3001/v1", api_key="freellmapi-your-unified-key", ) resp = client.chat.completions.create( model="auto", # or "auto:fast", "auto:smart", a profile, or a model id messages=[{"role": "user", "content": "Summarise the fall of Rome in one sentence."}], ) print(resp.choices[0].message.content) Every response carries an X-Routed-Via: <platform>/<model> header, so you can log which provider actually answered. What people are running on it From the builds tracked on the FreeLLMAPI page: - One builder routed Claude Code through FreeLLMAPI across Mistral, Gemini, Groq and Cerebras, tested balanced routing and automatic fallback, and wrote up the provider failures and rate limits they hit. - Another runs a 24/7 WhatsApp assistant on a single free-tier cloud VPS: Hermes Agent, a self-hosted FreeLLMAPI, a custom WhatsApp bridge and persistent memory. - A user built an Obsidian plugin that detects foreign-language text and translates it, running on pooled free tokens through the desktop app. - Someone packaged it as an app for a home NAS. FreeLLMAPI or LiteLLM? They overlap but aim at different jobs. LiteLLM is an AI gateway and Python SDK for calling 100+ providers through one OpenAI-format interface, with cost tracking, guardrails and load balancing, and it is the usual pick when you are paying for production traffic. FreeLLMAPI is local-first and single-user by design, and its catalog and router are built specifically around free-tier quotas. Caveats - The README is blunt about the trade-offs: no frontier models, variable latency, no SLA, and the effective intelligence of the endpoint dips late in the day as top models hit their daily caps, then resets at UTC midnight. - Free installs get the model catalog as a monthly snapshot, so a new model reaches them 30 days after it joins the live feed. Same-day updates are a paid tier. - You still manage your own provider keys and each provider's terms. - This walkthrough follows the README and has not been run end to end by us. Source repo: tashfeenahmed/freellmapi. License: MIT. Want the setup commands for 50 AI repos people actually ship with? Get the free AI Repos That Actually Ship pack: dedupedai.com

How a Stale Provider Catalog Breaks Your LLM Gateway at 3 AM How a Stale Provider Catalog Breaks Your LLM Gateway at 3 AM You wake to alerts: your LLM gateway is returning 400s, but all upstream providers report healthy. The failover chain triggers perfectly. The router rejects valid requests. You redeploy—same behavior. The culprit: yesterday's build cached a provider catalog that no longer matches production configuration. Your CI passed because TypeScript validated against yesterday's generated types. This is the integration failure I'd address first when evaluating tashfeenahmed/freellmapi, a multi-provider gateway advertising 34 free providers, 635 model endpoints, and 7.4 billion tokens per month behind one /v1 interface. Those are project claims, not independently verified measurements. The stated scope is personal experimentation, not production SLAs. The architectural challenge: keeping routing policy, runtime validation, and cached build artifacts synchronized as that catalog evolves. Put the Catalog Upstream of the Router I'd integrate the gateway through a small TypeScript monorepo rather than scatter provider-specific assumptions across applications. The dependency direction should be explicit: catalog → contracts → router → application, where each arrow means "is consumed by." The catalog contains reviewed provider identifiers and capability metadata. Contracts expose request schemas and types. The router translates an accepted request into an upstream call. Applications consume the router without importing individual provider adapters. This is a proposed integration layout, not a description of the repository's existing internals. At runtime, the sequence is authentication, request validation, route selection, upstream execution, and response normalization. Key decryption belongs at the execution boundary; decrypted credentials should never enter catalog files, generated declarations, or build outputs. A toy tutorial puts all this in one handler. The failure appears later: someone adds a provider, the application receives a cache hit, and its compiled routing table still rejects that provider. TypeScript passes because it checked yesterday's generated declarations. Validate Route Syntax Without Recursive Types For application-owned route identifiers, I prefer a small, bounded utility over recursively splitting arbitrary strings: type Provider = "free" | "custom"; type CheckedRoute<S extends string> = S extends `${infer P}:${infer M}` ? P extends Provider ? M extends "" | `${string}:${string}` ? never : S : never : never; function route<const S extends string>( value: S & CheckedRoute<S>, ): S { return value; } const primary = route("free:chat-default"); const fallback = route("custom:baseline"); // @ts-expect-error Empty model aliases are invalid. route("free:"); // @ts-expect-error Unknown provider namespace. route("unknown:chat-default"); These are local aliases, not claims about upstream model names. Resolve them through the catalog before forwarding requests. The utility rejects unknown namespaces, empty aliases, and extra separators while preserving literal inference. It deliberately does not prove that a model exists. Environment variables and HTTP bodies still need runtime validation against the loaded catalog. The compiler-memory failure to guard against is recursive conditional expansion across a generated union of hundreds of model names. Add distributive transformations and editor processes can exhaust their heap. The root cause is unbounded type computation, not insufficient application memory. Keep syntax validation shallow; represent catalog membership as data. Make the Dependency Graph Part of Cache Correctness For a Turborepo 2 integration workspace, I'd start with this root turbo.json: { "$schema": "https://turbo.build/schema.json", "envMode": "strict", "globalDependencies": [ "tsconfig.base.json", "biome.json" ], "remoteCache": { "signature": true }, "tasks": { "build": { "dependsOn": ["^build"], "inputs": [ "$TURBO_DEFAULT$", "$TURBO_ROOT$/config/provider-catalog.json" ], "outputs": [ "dist/**", ".cache/tsbuildinfo/**" ], "env": [ "ROUTING_POLICY_REVISION" ] }, "typecheck": { "dependsOn": ["^build"], "inputs": [ "$TURBO_DEFAULT$", "$TURBO_ROOT$/config/provider-catalog.json" ], "outputs": [] }, "lint": { "inputs": ["$TURBO_DEFAULT$"], "outputs": [] } } } This assumes each package's build emits into dist, with incremental metadata under .cache/tsbuildinfo. Its typecheck script should run tsc --noEmit --incremental false. Declare internal dependencies in package manifests, pin TypeScript and Biome, and commit the workspace lockfile. Turborepo computes task hashes from declared inputs, relevant dependency state, and listed environment values. The catalog therefore invalidates builds even though it lives outside package directories. Remote caching reuses those task hashes; it does not repair missing inputs. Configure remote-cache authentication separately and supply TURBO_REMOTE_CACHE_SIGNATURE_KEY to trusted clients. Signing protects artifact integrity, not correctness. Keep provider credentials out of build tasks entirely. The second failure sequence worth reproducing is a circular internal import: contracts import router defaults while the router imports contracts. Incremental declarations can then become order-dependent. Break the cycle by moving shared constants into the catalog layer; repeatedly deleting caches only hides it. Benchmark Transport Separately from Build Correctness For a controlled comparison, I'd place B-Lost's relay endpoint, https://b-lost.com/v1, behind the custom-provider adapter as an optional baseline. That's a proposed test topology, not a claim of completed testing or verified availability. Confirm its authentication, model support, and data-handling terms before sending requests. Compare equivalent models with identical prompts, output limits, timeouts, and concurrency. Record time to first token separately from completion latency. Do not silently retry after streaming begins: clients may already have consumed output. The Hardest Trade-Off The architecture I've outlined adds deliberate friction: a reviewed catalog, explicit dependency graph, and bounded type utilities. That friction is the design. It makes stale builds diagnosable rather than silent. It keeps compiler cost predictable rather than unbounded. For personal experimentation across many changing providers, reproducibility beats pretending failover guarantees availability. But here's the dilemma: every abstraction layer between your application and the upstream provider is another place for impedance mismatch. The gateway can normalize interfaces, but it can't normalize semantics. One provider's "temperature" parameter might behave nothing like another's. Streaming implementations differ. Error codes diverge. Rate limits are opaque. How much normalization is worth the maintenance cost? Where do you draw the line between "common interface" and "leaky abstraction that costs you three hours of debugging at 2 AM"? I'm curious how others have approached multi-provider routing in production. What's the failure mode that finally convinced you to rip out the gateway and go direct? Or what's the design decision that made it sustainable? Drop your war stories in the comments.

7 BILLION Free AI Tokens?! This Is CRAZY What if you could access over 7 billion free AI tokens every month and connect them to Claude Code or Codex? Meet FreeLLMAPI, a free, open-source GitHub project that brings together the free tiers of 34 AI providers and over 600 AI model endpoints through one dashboard. With FreeLLMAPI, you can access available models from families like Gemini, GPT, Kimi, Qwen, and DeepSeek to help with coding, building websites, generating images, creating audio, and automating AI workflows. But here's the best part: automatic model switching! When one AI provider hits its free usage limit, FreeLLMAPI can automatically route your requests to another available model, helping you continue without constantly switching between AI tools. You can even connect FreeLLMAPI to Claude Code and Codex to use compatible free-tier models for AI-powered coding. 🔗 Get FreeLLMAPI on GitHub: tashfeenahmed/freellmapi The 7.4-billion-token figure is the project's estimate of combined monthly free-tier capacity across providers, not a guaranteed allowance for each user. Provider limits and model availability vary. Subscribe to Maitis for more free AI tools, Claude Code tutorials, GitHub discoveries, and powerful AI workflows! #freeaitools #FreeLLMAPI #claudecode #aiagents #github #aimodels #AIForCoding #freeai #codex #geminiai #deepseek #aiautomation #aitools2026 #Maitis #shorts

نماذج كتير بالمجان مع هذا الريبو الرهيب | freellmapi في هذا الفيديو، نتعرف على مستودع (Repository) مميز يتيح لك الوصول إلى نماذج ذكاء اصطناعي متنوعة ومجانية بالكامل عبر freellmapi. نستعرض كيفية استخدامه والاستفادة منه في مشاريعك البرمجية بسهولة ودون أي تكاليف. 📌 أهم النقاط في الفيديو: ما هو freellmapi وكيف يعمل؟ كيفية إعداد المشروع وربط النماذج المجانية. تجربة عملية على استخدام النماذج في مهام مختلفة. 🔗 روابط مهمة: tashfeenahmed/freellmapi لا تنسَ الاشتراك في القناة وتفعيل زر الجرس لمتابعة كل جديد في عالم البرمجة والذكاء الاصطناعي! #ذكاء_اصطناعي #برمجة #freellmapi #LLM #OpenSource 00:00 - مقدمة ومميزات أداة freellmapi 01:05 - تحميل وتثبيت الأداة على ويندوز 01:42 - جولة سريعة داخل واجهة البرنامج 03:00 - إضافة مزود OpenRouter واختيار النماذج 04:29 - إضافة Groq واختيار نموذج Qwen 05:13 - إضافة مفتاح Google AI Studio ونماذج Gemini 06:14 - إضافة مزود NVIDIA Build ونموذج Nemotron 07:58 - تجربة النماذج عبر الـ Playground 09:13 - ربط الأداة وتشغيلها مع Claude Code 11:32 - ملخص وخاتمة [en-US] Get Many Models for Free with This Incredible Repo | freellmapi In this video, we'll explore a unique repository that gives you access to a variety of completely free AI models via Freellmapi. We'll demonstrate how to use it and leverage it in your software projects easily and at no cost. 📌 Key points covered in the video: What is Freellmapi and how does it work? How to set up a project and connect the free models. A practical demonstration of using the models in different tasks. 🔗 Important links: tashfeenahmed/freellmapi Don't forget to subscribe to the channel and turn on notifications to stay up-to-date with everything new in the world of programming and artificial intelligence! #ArtificialIntelligence #Programming #freellmapi #LLM #OpenSource 00:00 - Introduction and Features of the freellmapi Tool 01:05 - Downloading and Installing the Tool on Windows 01:42 - A Quick Look at the Program Interface 03:00 - Adding the OpenRouter Provider and Selecting Models 04:29 - Adding Groq and Selecting the Qwen Model 05:13 - Adding the Google AI Studio Key and Gemini Models 06:14 - Adding the NVIDIA Build Provider and the Nemotron Model 07:58 - Testing Models via Playground 09:13 - Connecting and Running the Tool with Cloud Code 11:32 - Summary and Conclusion

paying for api calls while free tiers sit unused is a choice. freellmapi routes you through 34 free llm providers and 635 free model endpoints — 7.4 billion tokens a month, no key juggling, one api. tashfeenahmed/freellmapi

How Software Engineers Slash Claude AI Bills by -95%: FreeLLMAPI & OmniRoute Setup Software engineering has entered the agentic era. Tools like Cursor IDE, Claude Code CLI, Cline, and Windsurf make writing code 10x faster. But as anyone running autonomous agents knows, token bills add up quickly. A single refactoring loop or bug reproduction can easily burn 300,000+ tokens. At standard Anthropic rates ($3/M input and $15/M output for Claude 3.5 Sonnet), software engineers easily rack up $100 to $300 every month on personal credit cards. Recently, two open-source projects have gained viral traction in the developer community: 1. tashfeenahmed/freellmapi (38.6k stars): Aggregates 34 free provider tiers and pools 635 model endpoints behind a single OpenAI/Anthropic /v1 endpoint, managing 7.4 billion tokens per month. 2. diegosouzapw/OmniRoute (79.1k stars): A high-performance AI gateway that dynamically routes prompts to free high-speed models (Llama 3.3 70B, DeepSeek V3, Qwen 2.5 Coder 32B) and fails over seamlessly in under 15 milliseconds. > 💬 Join our Developer Community: For daily verified free AI API keys, token configs, and automated setup scripts, join our official VIP WhatsApp Developer Community and Telegram Channel. > > 🔗 Full Windows 1-Click batch installer, interactive unlock gate, and step-by-step screenshots are published on OrissaPublishers: FreeLLMAPI & OmniRoute Claude Token Hack. --- 1. The Multi-Provider Routing Architecture Major cloud providers (Cerebras, Groq, Cloudflare Workers AI, GitHub Models, Together AI, HuggingFace) offer generous free developer tiers: - Cerebras: Up to 1M free tokens/day at 1,800 tokens/second. - Groq Cloud: Free high-speed Llama 3.1 & 3.3 inference with zero latency. - GitHub Models / Azure: Free developer tier with GPT-4o-mini and Claude-compatible routing. The bottleneck has always been managing 30+ separate API keys, diverse SDK specifications, and sudden HTTP 429 rate limits. FreeLLMAPI and OmniRoute solve this with a 3-tier proxy: 1. Smart Model Mapping: When your IDE asks for claude-3-5-sonnet, OmniRoute maps it to the best available free reasoning model (e.g., DeepSeek R1/V3 or Qwen 2.5 Coder 32B). 2. Dynamic Failover: If Provider A returns a 429 rate limit or 503 gateway timeout, the proxy retries on Provider B within 15 milliseconds. 3. Zero IDE Interruptions: Your editor never encounters connection crashes. --- 2. Quickstart with Docker Compose You can launch the complete gateway locally in less than 2 minutes: # 1. Clone the repository git clone https://github.com/tashfeenahmed/freellmapi.git cd freellmapi # 2. Setup your environment cp .env.example .env # 3. Spin up the container docker compose up -d The gateway will now be live on http://127.0.0.1:8000/v1. --- 3. Connecting to Cursor IDE & Claude Code CLI A. Cursor IDE 1. Open Cursor Settings > Models. 2. Turn on OpenAI API Key and enter any string (e.g. sk-free-token-2026). 3. Set Override OpenAI Base URL to: http://127.0.0.1:8000/v1 4. Add model names: claude-3-5-sonnet-20241022, deepseek-chat, or qwen-2.5-coder-32b. B. Claude Code CLI In your PowerShell or Bash terminal: # PowerShell $env:ANTHROPIC_BASE_URL="http://127.0.0.1:8000/v1" ; claude # Bash / Zsh export ANTHROPIC_BASE_URL="http://127.0.0.1:8000/v1" claude --- 4. Resources & Community - Official Repositories: - FreeLLMAPI: tashfeenahmed/freellmapi - OmniRoute: diegosouzapw/OmniRoute - VIP WhatsApp Group: Join here for daily API keys - Original Full Tutorial & 1-Click Vault: OrissaPublishers Article

手头好几个免费模型 API 换来换去很麻烦？这个项目把 34 家免费 LLM 提供商、635 个免费模型端点收进一个 /v1 接口，自动选路、失败自动切换，密钥还加密存着。想一次性试遍各家免费模型、做个人实验的，可以拿它当统一入口练手。注意作者注明仅限个人实验，别当生产服务用。 tashfeenahmed/freellmapi

FREE → ~7.4 BILLION tokens per month > 7.4 billion tokens per month > 34 free LLM providers > 635 free model endpoints All behind one /v1 endpoint, plus support for any custom OpenAI-compatible endpoint. - Smart Routing - Automatic Failover - Encrypted Keys - Personal Experimentation Only --- Disclaimer: I am not the creator or affiliated with this project, just sharing!

9 Billion AI Token free 🤯 These 2 GitHub repositories could help you explore free AI 👇🏻 🤯🧑🏻‍💻👇🏻 Hey! Here are the 2 GitHub repositories for free AI tokens. 1. OmniRoute cheaper-inference/OmniRoute 2. FreeLLMAPI tashfeenahmed/freellmapi Explore both repositories and follow the setup instructions to get started! Note: Token limits depend on provider quotas, account eligibility, and availability.

FreeLLMAPI routes requests across 34 free LLM providers behind a single OpenAI-compatible endpoint so you avoid juggling API keys. tashfeenahmed/freellmapi #TypeScript #AI #LLM #Embeddings #Docker