Primary question: Do you trust a community proxy to sit between your API keys, your coding agent, and your third-party model provider?
RepoDaily adoption score
RepoDaily rates this as 86/100 (strong) for adoption: evidence, installation path, production risk, differentiation, license clarity, and AI/agent fit are scored from the article sources and adoption notes.
4 source(s) across 3 source category/categories, plus a RepoDaily-specific evidence module when available.
6 workflow step(s), 5 next-action step(s), and 6 command/install signal(s) were detected.
Trending momentum is +449 stars, with maintenance/release/issue signals counted when present.
Risk is marked high, with 5 security note(s) and 4 explicit skip condition(s).
3 opportunity lens item(s), 4 alternative(s), and 4 type-specific section(s) support differentiation.
License source or license wording is present.
8 AI/agent-related signal(s) were detected in the article text and metadata.
Project overview
Free Claude Code (FCC) is a local proxy written in Python 3.14 that connects coding agents — Claude Code, the Codex CLI, and Pi — to OpenAI-compatible model providers. Instead of binding a single agent to a single vendor, FCC exposes one local Admin UI where you pick, validate, and switch among 31 cloud and local providers. The project is MIT licensed and maintained under the name Ali Khokhar, with version 4.16.7 in pyproject.toml at the time of this trend.
The package is built on FastAPI and uvicorn, with httpx for outbound calls, pydantic and pydantic-settings for configuration, and loguru for logging. It ships four console scripts — fcc-server, fcc-claude, fcc-codex, fcc-pi — plus a desktop entry point named fcc-desktop for Windows and macOS tray launches. Each coding agent keeps its native /model picker, while FCC generates a model catalog behind the scenes.
FCC positions itself as infrastructure for people who want to use free, paid, or local models interchangeably from inside tools they already run. It is not a model host and it is not a coding agent itself; it is a routing and protocol-conversion layer that preserves streaming, tool use, reasoning, and image input where the underlying provider supports them.
Beyond terminal launches, the project adds bridges to VS Code, JetBrains through ACP, and messaging surfaces like Discord and Telegram with optional voice-note transcription. Those bridges are opt-in extras rather than the core value, but they expand the surface area considerably for a single-maintainer project.
Why it is trending now
- Period stars of 449 and rank 15 indicate concentrated attention in a narrow window, consistent with developer tooling that solves an immediate, painful cost problem.
- Claude Code and Codex CLI users who hit usage limits or want cheaper fallback models now have one local proxy that targets 31 providers instead of hand-rolling adapters.
- Voice and messaging integrations (Discord, Telegram, voice transcription) push FCC beyond a plain proxy into a lightweight agent gateway, which is the kind of project that travels well in social channels.
- The installer story is unusually polished for a community project: one curl | sh on macOS/Linux and one PowerShell one-liner on Windows, plus desktop launchers.
Problem it solves
- Coding agents like Claude Code and Codex assume a fixed provider relationship, so swapping models means writing protocol glue or changing API keys repeatedly.
- Free-tier and local model providers are fragmented, each with their own quirks around streaming, tool calls, and image input.
- Teams that want fallback chains — for example, route Opus traffic to one provider and Sonnet to another — have no built-in place to express that today.
- Mobile and chat-driven coding sessions are awkward to wire up because the native agent CLIs expect a terminal, not a Discord or Telegram message.
How it works
- Install FCC with the curl | sh installer on macOS/Linux or the PowerShell one-liner on Windows; the installer asks which coding agents to install or verify.
- Start fcc-server locally, or open the desktop launcher on Windows or macOS, which exposes the local Admin UI.
- From the Admin UI, choose and validate one of 31 cloud or local providers and enter the credentials FCC needs to call them.
- Launch a coding agent with fcc-claude, fcc-codex, or fcc-pi; the agent talks to the local FCC endpoint instead of its default vendor.
- Use the agent's native /model picker to select from FCC's generated model catalog; FCC converts between Anthropic and OpenAI-style protocols as needed.
- Optionally enable token authentication on the proxy, or wire up Discord, Telegram, or voice transcription extras.
Product demo and interface preview
Architecture read: where the moving parts live
- Core Anthropic protocol behavior lives under src/free_claude_code/core/anthropic/, and provider-specific configuration stays inside the provider that owns it — CONTRIBUTING.md explicitly bans importing utilities across providers.
- Launcher entrypoints live at free_claude_code.cli.launchers.claude, .codex, and .pi, each exposing a launch() callable referenced by the fcc-* console scripts in pyproject.toml.
- The server entrypoint is free_claude_code.cli.entrypoints:serve, with a separate desktop GUI entry at free_claude_code.cli.desktop_entrypoint:launch.
- FCC is built on FastAPI[standard] >= 0.139.2, uvicorn >= 0.51.0, httpx[socks] >= 0.28.1, pydantic >= 2.13.4, and python-dotenv >= 1.2.2.
- Platform-specific dependencies (pystray and Pillow) are scoped to Windows and macOS so the tray launcher does not pollute Linux installs.
Command surface: what you actually run
- fcc-server starts the local proxy; fcc-claude, fcc-codex, and fcc-pi launch the corresponding coding agents through it.
- fcc-desktop opens the Windows or macOS desktop launcher declared in [project.gui-scripts].
- Install: curl -fsSL https://raw.githubusercontent.com/Alishahryar1/free-claude-code/main/scripts/install.sh | sh on macOS/Linux.
- Install: & ([scriptblock]::Create((irm https://raw.githubusercontent.com/Alishahryar1/free-claude-code/main/scripts/install.ps1))) on Windows PowerShell.
- Re-running the same installer command updates FCC; the README notes you can review install.sh and install.ps1 before executing them.
- Local CI: ./scripts/ci.sh or .\scripts\ci.ps1, with --only, --skip, and --dry-run flags for iteration.
Integration surface: agents, IDEs, and messaging
- Connects Claude Code and Codex inside VS Code, plus Claude Code through JetBrains ACP.
- Optional Discord and Telegram bridges use discord.py >= 2.7.1 and python-telegram-bot >= 22.8 from the core dependency set, not an extra.
- Voice transcription has two paths: the voice extra (grpcio, grpcio-tools, nvidia-riva-client >= 2.26.0) and the voice_local extra (torch >= 2.13.0, transformers >= 5.14.1, librosa >= 0.10.0).
- Optional token authentication protects the local proxy endpoint.
- Model routing can split Fable, Opus, Sonnet, and Haiku traffic to different models, which is the actual reason to run FCC beyond a single provider swap.
Maintenance and quality posture
- Targeted at Python 3.14 with native lazy annotations; CONTRIBUTING.md forbids from __future__ import annotations and bans # type: ignore and # ty: ignore suppressions in CI.
- Type checking uses ty >= 0.0.60, formatting and linting use Ruff >= 0.15.22, and tests run on pytest >= 9.1.1 with pytest-asyncio, pytest-cov, and pytest-xdist.
- Every runtime, packaging, dependency, or install/CI change requires a semantic version bump in pyproject.toml plus a matching uv lock update in the same commit.
- Contributing rules forbid Docker integration pull requests outright, which narrows how some teams will be able to deploy FCC.
- ARCHITECTURE.md is the source of truth for extension checklists, package boundaries, providers, protocol conversion, launchers, and messaging.
Who should pay attention?
Good fit if
- Individuals who already run Claude Code or Codex CLI and want to try cheaper or local fallback providers without forking the agents.
- Power users who want per-model routing — for example, Opus traffic to a strong provider and Haiku to a cheap one.
- People who want to drive coding agents from Telegram or Discord with voice notes, since FCC bundles those bridges.
- Developers on Python 3.14 who are comfortable with uv, Ruff, and a single-maintainer project.
Skip for now if
- Enterprises that need a vendor-backed proxy with SLAs, audit logs, and formal security review.
- Teams that require Docker-only deployments; CONTRIBUTING.md says Docker PRs will not be accepted.
- Anyone who cannot run Python 3.14 or who needs long-term support for older interpreters.
- Users uncomfortable piping a remote install script into sh or PowerShell without review.
Risks and cautions
FCC sits between your credentials, your coding agent, and your model provider, and it is maintained by a single individual — which is the dominant risk regardless of how clean the code looks.
- Single-maintainer project under one GitHub account, with no visible organization or vendor backing.
- The proxy handles API keys and all coding-agent traffic, so any compromise or bug can leak credentials or source material.
- Install flow pipes a remote script into sh or PowerShell; the README invites review but many users will skip it.
- Python 3.14 is a hard requirement, which limits deployment flexibility on locked-down environments.
- No Docker support is accepted, closing off a common isolation path for self-hosted tooling.
- Optional token authentication is available on the local proxy, but the README frames it as opt-in rather than default.
- Dependencies include httpx[socks], requests[socks], google-auth[requests], and openai >= 2.46.0, so the supply chain is broad for a local proxy.
- The installer fetches and executes scripts over HTTPS from the main branch; re-running updates pulls whatever is on main at that moment.
- No security policy, threat model, or disclosure process is visible in the README, CONTRIBUTING.md, or pyproject.toml.
- Messaging and voice extras (discord.py, python-telegram-bot, nvidia-riva-client, torch) expand the attack surface well beyond the core proxy.
Alternatives to compare
| Approach | When to use | Trade-off |
|---|---|---|
LiteLLM | You want a widely adopted OpenAI-compatible proxy with provider routing, key management, and broader production use. | Open source, self-hosted; hosted LiteLLM available separately. |
OneAPI / New API style gateways | You need multi-tenant key management and billing-style metering on top of provider routing. | Open source, self-hosted. |
Claude Code and Codex CLI with native provider keys | You are happy with the default vendor relationship and do not need fallback chains or messaging bridges. | Usage-based vendor pricing. |
Ollama | Your goal is running local models rather than routing multiple cloud providers behind coding agents. | Open source, self-hosted. |
What this trend reveals
Cost arbitrage across fallback chains
Routing Opus to a strong provider and Haiku or Sonnet to cheaper ones lets a solo developer cut spend without editing agent code, which is the clearest payback for adopting FCC.
Pick a representative coding task, run it through the default vendor for a week, then run the same task through FCC with fallback routing and compare token spend and completion quality.
Agent gateway for chat-driven development
Discord and Telegram bridges with voice transcription turn a terminal-first agent into a mobile coding assistant, which is unusual for a proxy at this size.
Stand up FCC with one provider, enable the Telegram bridge, and verify voice notes transcribe and reach the agent end-to-end before relying on it.
Protocol conversion for mixed toolchains
Because FCC converts between Anthropic-style and OpenAI-compatible protocols in src/free_claude_code/core/anthropic/, teams that already standardize on OpenAI-compatible providers can add Claude Code without a second key management setup.
Confirm streaming, tool use, reasoning, and image input survive the conversion for your specific provider before adopting it for production work.
RepoDaily verdict
Free Claude Code is a focused, well-tooled local proxy that solves a real routing problem for Claude Code and Codex users willing to run Python 3.14 and trust a single-maintainer project with their credentials. Adopt it for personal experimentation and fallback routing; be far more cautious before letting it carry production traffic or sensitive code.