---
title: "免费 LLM API 完全指南：11 个平台详细教程与统一封装方案"
author: deletexiumu
pubDatetime: 2026-02-14T12:00:00+08:00
featured: false
draft: false
tags:
  - API
  - AI 编程
  - AI 工具
description: "全面梳理 11 个提供免费 LLM API 的平台，涵盖注册流程、API 调用示例、额度对比，并提供一套 Python 统一封装方案，支持多平台自动 fallback。"
---

## 前言

2026 年，大语言模型（LLM）的 API 生态已经非常成熟。对于独立开发者、学生和技术爱好者来说，一个好消息是：你不需要花一分钱，就能调用包括 Gemini 2.5、Llama 3.3、Qwen 3、DeepSeek 在内的顶级开源和闭源模型。

从 Google AI Studio 的每月 10 亿 token 免费额度，到 Groq 超快的推理速度，再到 OpenRouter 聚合的 30+ 免费模型——这些平台为开发者提供了零成本试验和构建 AI 应用的机会。本文整理自 GitHub 上 [cheahjs/free-llm-api-resources](https://github.com/cheahjs/free-llm-api-resources) 这个优秀的开源项目，并在此基础上补充了完整的注册流程、代码示例和统一封装方案。

无论你是想快速搭建原型、做学术研究，还是纯粹想玩一玩最新的模型，这篇指南都能帮你找到合适的免费资源。

---

## 一、平台详细教程

### 1. Google AI Studio（强烈推荐）

- **官网**：https://aistudio.google.com
- **免费额度**：Gemini 2.5 Flash 20 requests/天；Gemma 3 系列 14,400 requests/天；250,000 tokens/分钟
- **支持模型**：Gemini 2.5 Flash、Gemini 2.5 Pro（限量）、Gemma 3 27B/12B/4B/1B
- **注册流程**：使用 Google 账号登录即可，无需信用卡，无需手机验证
- **注意事项**：UK/CH/EEA/EU 以外地区，免费版数据可能用于模型训练

**curl 示例：**

```bash
# 设置 API Key
export GOOGLE_API_KEY="your-api-key-here"

# 调用 Gemini 2.5 Flash
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${GOOGLE_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [{"text": "用一句话解释什么是 Transformer 架构"}]
    }]
  }'
```

**Python 示例（google-generativeai SDK）：**

```python
import google.generativeai as genai
import os

genai.configure(api_key=os.environ["GOOGLE_API_KEY"])

model = genai.GenerativeModel("gemini-2.5-flash")
response = model.generate_content("用一句话解释什么是 Transformer 架构")
print(response.text)
```

---

### 2. Groq（最快推理）

- **官网**：https://console.groq.com
- **免费额度**：按模型不同，Llama 3.1 8B 14,400 requests/天，Llama 3.3 70B 1,000 requests/天
- **支持模型**：Llama 3.3 70B、Llama 3.1 8B、Whisper Large v3（语音转文字）、Gemma 2 9B 等 20+ 模型
- **注册流程**：Google/GitHub 账号一键注册，即刻获取 API Key
- **API 兼容性**：完全兼容 OpenAI API 格式

**curl 示例：**

```bash
export GROQ_API_KEY="your-api-key-here"

curl https://api.groq.com/openai/v1/chat/completions \
  -H "Authorization: Bearer ${GROQ_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3.3-70b-versatile",
    "messages": [
      {"role": "user", "content": "用一句话解释什么是 RAG"}
    ],
    "temperature": 0.7
  }'
```

**Python 示例（openai SDK）：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

response = client.chat.completions.create(
    model="llama-3.3-70b-versatile",
    messages=[{"role": "user", "content": "用一句话解释什么是 RAG"}],
    temperature=0.7,
)
print(response.choices[0].message.content)
```

---

### 3. OpenRouter（模型最多）

- **官网**：https://openrouter.ai
- **免费额度**：20 requests/分钟，50 requests/天（充值 $10 可升级至 1,000 requests/天）
- **支持模型**：30+ 免费模型，包括 Gemma 3、Llama 3.x、Mistral、Qwen、DeepSeek 等
- **注册流程**：Google/GitHub 账号注册，进入 Dashboard 创建 API Key
- **API 兼容性**：完全兼容 OpenAI API 格式

**curl 示例：**

```bash
export OPENROUTER_API_KEY="your-api-key-here"

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer ${OPENROUTER_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/gemma-3-27b-it:free",
    "messages": [
      {"role": "user", "content": "对比 RAG 和 Fine-tuning 的优缺点"}
    ]
  }'
```

**Python 示例：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["OPENROUTER_API_KEY"],
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat.completions.create(
    model="google/gemma-3-27b-it:free",
    messages=[{"role": "user", "content": "对比 RAG 和 Fine-tuning 的优缺点"}],
)
print(response.choices[0].message.content)
```

---

### 4. Mistral（额度最大）

- **官网**：https://console.mistral.ai
- **免费额度**：1 request/秒，500,000 tokens/分钟，**10 亿 tokens/月**
- **支持模型**：Mistral Large、Mistral Small、Mistral Nemo、Codestral（编程专用）
- **注册流程**：邮箱注册，需手机验证；免费版需同意数据训练条款
- **特色**：Codestral 端点 `codestral.mistral.ai` 单独提供 2,000 requests/天

**curl 示例：**

```bash
export MISTRAL_API_KEY="your-api-key-here"

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small-latest",
    "messages": [
      {"role": "user", "content": "写一个 Python 快速排序函数"}
    ]
  }'
```

**Python 示例：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["MISTRAL_API_KEY"],
    base_url="https://api.mistral.ai/v1",
)

response = client.chat.completions.create(
    model="mistral-small-latest",
    messages=[{"role": "user", "content": "写一个 Python 快速排序函数"}],
)
print(response.choices[0].message.content)
```

---

### 5. Cerebras（硬件级加速）

- **官网**：https://cloud.cerebras.ai
- **免费额度**：按模型不同，约 30 requests/分钟，60,000 tokens/分钟
- **支持模型**：Qwen 3 235B、Llama 3.3 70B、Llama 3.1 8B、GLM 4 系列
- **注册流程**：邮箱注册，即刻获取 API Key
- **API 兼容性**：完全兼容 OpenAI API 格式
- **特色**：基于 Cerebras 晶圆级芯片，推理速度极快

**curl 示例：**

```bash
export CEREBRAS_API_KEY="your-api-key-here"

curl https://api.cerebras.ai/v1/chat/completions \
  -H "Authorization: Bearer ${CEREBRAS_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3.3-70b",
    "messages": [
      {"role": "user", "content": "解释 Cerebras 晶圆级芯片的技术优势"}
    ]
  }'
```

**Python 示例：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["CEREBRAS_API_KEY"],
    base_url="https://api.cerebras.ai/v1",
)

response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "解释 Cerebras 晶圆级芯片的技术优势"}],
)
print(response.choices[0].message.content)
```

---

### 6. SambaNova

- **官网**：https://cloud.sambanova.ai
- **免费额度**：$5 试用额度，有效期 3 个月
- **支持模型**：DeepSeek R1/V3、Llama 3.3 70B、Qwen 2.5 等
- **注册流程**：邮箱注册，获取试用额度
- **API 兼容性**：兼容 OpenAI API 格式

**Python 示例：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["SAMBANOVA_API_KEY"],
    base_url="https://api.sambanova.ai/v1",
)

response = client.chat.completions.create(
    model="DeepSeek-R1",
    messages=[{"role": "user", "content": "什么是量子计算？"}],
)
print(response.choices[0].message.content)
```

---

### 7. GitHub Models

- **官网**：https://github.com/marketplace/models
- **免费额度**：基于 Copilot 订阅等级，免费版额度较低且 token 限制严格
- **支持模型**：40+ 模型，包括 OpenAI GPT-4o、Meta Llama、Mistral、Cohere、DeepSeek 等
- **注册流程**：已有 GitHub 账号即可使用，进入 Marketplace 获取 token
- **API 兼容性**：兼容 OpenAI API 格式

**Python 示例：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["GITHUB_TOKEN"],
    base_url="https://models.inference.ai.azure.com",
)

response = client.chat.completions.create(
    model="meta-llama-3.1-8b-instruct",
    messages=[{"role": "user", "content": "GitHub Copilot 的工作原理是什么？"}],
)
print(response.choices[0].message.content)
```

---

### 8. HuggingFace Inference

- **官网**：https://huggingface.co/docs/inference-providers
- **免费额度**：每月 $0.10 等值额度
- **支持模型**：小于 10GB 的开源模型（部分热门大模型例外）
- **注册流程**：HuggingFace 账号注册，获取 Access Token
- **特色**：直接调用 HuggingFace Hub 上托管的任意模型

**Python 示例：**

```python
from huggingface_hub import InferenceClient
import os

client = InferenceClient(token=os.environ["HF_TOKEN"])

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[{"role": "user", "content": "什么是注意力机制？"}],
    max_tokens=500,
)
print(response.choices[0].message.content)
```

---

### 9. Cloudflare Workers AI

- **官网**：https://developers.cloudflare.com/workers-ai
- **免费额度**：10,000 neurons/天
- **支持模型**：50+ 模型，包括 Llama 3、Gemma 2、Qwen 2.5、DeepSeek R1 蒸馏版等
- **注册流程**：注册 Cloudflare 账号，在 Dashboard 中启用 Workers AI，获取 Account ID 和 API Token
- **特色**：边缘部署，全球低延迟

**curl 示例：**

```bash
export CF_ACCOUNT_ID="your-account-id"
export CF_API_TOKEN="your-api-token"

curl "https://api.cloudflare.com/client/v4/accounts/${CF_ACCOUNT_ID}/ai/run/@cf/meta/llama-3.1-8b-instruct" \
  -H "Authorization: Bearer ${CF_API_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Cloudflare Workers 的架构是什么？"}
    ]
  }'
```

**Python 示例（OpenAI 兼容端点）：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["CF_API_TOKEN"],
    base_url=f"https://api.cloudflare.com/client/v4/accounts/{os.environ['CF_ACCOUNT_ID']}/ai/v1",
)

response = client.chat.completions.create(
    model="@cf/meta/llama-3.1-8b-instruct",
    messages=[{"role": "user", "content": "Cloudflare Workers 的架构是什么？"}],
)
print(response.choices[0].message.content)
```

---

### 10. Vercel AI Gateway

- **官网**：https://vercel.com/docs/ai-gateway
- **免费额度**：$5/月（Vercel 免费套餐附带）
- **支持模型**：路由到多个后端供应商（OpenAI、Anthropic、Google 等）
- **注册流程**：注册 Vercel 账号，在项目设置中启用 AI Gateway
- **特色**：统一网关，自动路由到最优供应商；与 Vercel 部署深度集成

**Python 示例（使用 Vercel AI SDK）：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["VERCEL_API_KEY"],
    base_url="https://api.vercel.ai/v1",
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Next.js 和 Nuxt.js 有什么区别？"}],
)
print(response.choices[0].message.content)
```

---

### 11. 阿里云百炼（国内首选）

- **官网**：https://bailian.console.alibabacloud.com
- **免费额度**：每个模型 100 万 tokens（一次性）
- **支持模型**：Qwen 3、Qwen 2.5 全系列、Qwen-VL（视觉）、Qwen-Audio
- **注册流程**：阿里云账号登录，进入百炼控制台，开通模型服务，创建 API Key
- **特色**：国内直连，无需科学上网，中文优化最好
- **API 兼容性**：兼容 OpenAI API 格式

**curl 示例：**

```bash
export DASHSCOPE_API_KEY="your-api-key-here"

curl https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
  -H "Authorization: Bearer ${DASHSCOPE_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-plus",
    "messages": [
      {"role": "user", "content": "解释一下大模型的涌现能力"}
    ]
  }'
```

**Python 示例：**

```python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

response = client.chat.completions.create(
    model="qwen-plus",
    messages=[{"role": "user", "content": "解释一下大模型的涌现能力"}],
)
print(response.choices[0].message.content)
```

---

## 二、统一封装方案

上面 11 个平台中，绝大多数都兼容 OpenAI API 格式。这意味着我们可以用一套代码统一调用，并实现自动 fallback——当一个平台的配额用完时，自动切换到下一个平台。

以下是一个完整可运行的 Python 封装类：

```python
"""
FreeLLMClient - 免费 LLM API 统一封装
支持多平台自动 fallback，基于 openai SDK

安装依赖：pip install openai
"""

from __future__ import annotations

import os
import time
import logging
from dataclasses import dataclass, field
from typing import Optional

from openai import OpenAI, APIError, RateLimitError, APIConnectionError

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("FreeLLMClient")


@dataclass
class ProviderConfig:
    """单个 LLM 供应商配置"""
    name: str
    base_url: str
    api_key_env: str
    default_model: str
    models: list[str] = field(default_factory=list)

    @property
    def api_key(self) -> Optional[str]:
        return os.environ.get(self.api_key_env)

    @property
    def available(self) -> bool:
        return self.api_key is not None


# ── 供应商注册表 ──────────────────────────────────────────────

PROVIDERS: dict[str, ProviderConfig] = {
    "groq": ProviderConfig(
        name="Groq",
        base_url="https://api.groq.com/openai/v1",
        api_key_env="GROQ_API_KEY",
        default_model="llama-3.3-70b-versatile",
        models=["llama-3.3-70b-versatile", "llama-3.1-8b-instant", "gemma2-9b-it"],
    ),
    "cerebras": ProviderConfig(
        name="Cerebras",
        base_url="https://api.cerebras.ai/v1",
        api_key_env="CEREBRAS_API_KEY",
        default_model="llama-3.3-70b",
        models=["llama-3.3-70b", "llama-3.1-8b"],
    ),
    "openrouter": ProviderConfig(
        name="OpenRouter",
        base_url="https://openrouter.ai/api/v1",
        api_key_env="OPENROUTER_API_KEY",
        default_model="google/gemma-3-27b-it:free",
        models=["google/gemma-3-27b-it:free", "meta-llama/llama-3.3-70b-instruct:free"],
    ),
    "mistral": ProviderConfig(
        name="Mistral",
        base_url="https://api.mistral.ai/v1",
        api_key_env="MISTRAL_API_KEY",
        default_model="mistral-small-latest",
        models=["mistral-small-latest", "mistral-large-latest"],
    ),
    "sambanova": ProviderConfig(
        name="SambaNova",
        base_url="https://api.sambanova.ai/v1",
        api_key_env="SAMBANOVA_API_KEY",
        default_model="DeepSeek-R1",
        models=["DeepSeek-R1", "Meta-Llama-3.3-70B-Instruct"],
    ),
    "github": ProviderConfig(
        name="GitHub Models",
        base_url="https://models.inference.ai.azure.com",
        api_key_env="GITHUB_TOKEN",
        default_model="meta-llama-3.1-8b-instruct",
        models=["meta-llama-3.1-8b-instruct", "gpt-4o-mini"],
    ),
    "dashscope": ProviderConfig(
        name="阿里云百炼",
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
        api_key_env="DASHSCOPE_API_KEY",
        default_model="qwen-plus",
        models=["qwen-plus", "qwen-turbo", "qwen-max"],
    ),
}

# ── fallback 顺序（按推荐优先级排列）──────────────────────────

FALLBACK_ORDER: list[str] = [
    "groq", "cerebras", "openrouter", "mistral",
    "sambanova", "github", "dashscope",
]


class FreeLLMClient:
    """免费 LLM API 统一客户端，支持多平台自动 fallback"""

    def __init__(
        self,
        default_provider: Optional[str] = None,
        fallback_order: Optional[list[str]] = None,
        max_retries: int = 2,
    ) -> None:
        self.default_provider = default_provider or os.environ.get("LLM_PROVIDER", "groq")
        self.fallback_order = fallback_order or FALLBACK_ORDER
        self.max_retries = max_retries
        self._clients: dict[str, OpenAI] = {}

    def _get_client(self, provider_key: str) -> OpenAI:
        """获取或创建某个供应商的 OpenAI 客户端"""
        if provider_key not in self._clients:
            config = PROVIDERS[provider_key]
            if not config.available:
                raise ValueError(
                    f"供应商 {config.name} 的 API Key 未设置，"
                    f"请设置环境变量 {config.api_key_env}"
                )
            self._clients[provider_key] = OpenAI(
                api_key=config.api_key,
                base_url=config.base_url,
            )
        return self._clients[provider_key]

    def chat(
        self,
        messages: list[dict[str, str]],
        model: Optional[str] = None,
        provider: Optional[str] = None,
        **kwargs,
    ) -> str:
        """
        向指定供应商发送对话请求

        Args:
            messages: OpenAI 格式的消息列表
            model: 模型名称，为空则使用供应商默认模型
            provider: 供应商 key，为空则使用默认供应商
            **kwargs: 传递给 chat.completions.create 的额外参数

        Returns:
            模型的文本回复
        """
        provider_key = provider or self.default_provider
        config = PROVIDERS[provider_key]
        model = model or config.default_model
        client = self._get_client(provider_key)

        logger.info(f"调用 {config.name}，模型: {model}")
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            **kwargs,
        )
        return response.choices[0].message.content or ""

    def chat_with_fallback(
        self,
        messages: list[dict[str, str]],
        **kwargs,
    ) -> str:
        """
        带自动 fallback 的对话请求。
        按优先级依次尝试各供应商，遇到限流或连接错误时自动切换。

        Args:
            messages: OpenAI 格式的消息列表
            **kwargs: 传递给 chat.completions.create 的额外参数

        Returns:
            模型的文本回复

        Raises:
            RuntimeError: 所有供应商均失败
        """
        errors: list[str] = []

        for provider_key in self.fallback_order:
            config = PROVIDERS[provider_key]
            if not config.available:
                logger.debug(f"跳过 {config.name}（API Key 未设置）")
                continue

            for attempt in range(1, self.max_retries + 1):
                try:
                    return self.chat(
                        messages=messages,
                        provider=provider_key,
                        **kwargs,
                    )
                except RateLimitError as e:
                    msg = f"{config.name} 限流: {e}"
                    logger.warning(msg)
                    errors.append(msg)
                    # 限流直接换下一个供应商，不重试
                    break
                except (APIConnectionError, APIError) as e:
                    msg = f"{config.name} 第{attempt}次错误: {e}"
                    logger.warning(msg)
                    errors.append(msg)
                    if attempt < self.max_retries:
                        wait = 2 ** attempt
                        logger.info(f"等待 {wait}s 后重试...")
                        time.sleep(wait)

        raise RuntimeError(
            f"所有供应商均失败。错误列表:\n" +
            "\n".join(f"  - {e}" for e in errors)
        )

    def list_available_providers(self) -> list[dict[str, str]]:
        """列出所有已配置 API Key 的可用供应商"""
        result = []
        for key in self.fallback_order:
            config = PROVIDERS[key]
            if config.available:
                result.append({
                    "key": key,
                    "name": config.name,
                    "default_model": config.default_model,
                    "models": ", ".join(config.models),
                })
        return result


# ── 使用示例 ──────────────────────────────────────────────────

if __name__ == "__main__":
    client = FreeLLMClient()

    # 列出可用供应商
    print("可用供应商：")
    for p in client.list_available_providers():
        print(f"  {p['name']} ({p['key']}) - 默认模型: {p['default_model']}")
    print()

    messages = [{"role": "user", "content": "用三句话介绍 Python 的优点"}]

    # 方式一：指定供应商
    # result = client.chat(messages, provider="groq")

    # 方式二：自动 fallback（推荐）
    result = client.chat_with_fallback(messages)
    print(f"回复：\n{result}")
```

**使用方式：**

```bash
# 设置你拥有的 API Key（设多少个都行，fallback 会自动跳过未设置的）
export GROQ_API_KEY="gsk_xxx"
export CEREBRAS_API_KEY="csk_xxx"
export OPENROUTER_API_KEY="sk-or-xxx"

# 运行
python free_llm_client.py
```

核心设计思路：

1. **环境变量驱动**：通过 `LLM_PROVIDER` 指定默认供应商，各平台的 API Key 也通过独立的环境变量管理
2. **统一接口**：所有供应商统一为 `chat()` 方法，底层都走 `openai` SDK
3. **自动 fallback**：`chat_with_fallback()` 按优先级依次尝试，遇到限流立即切换下一家，遇到网络错误指数退避重试
4. **零侵入扩展**：新增供应商只需往 `PROVIDERS` 字典加一条配置

---

## 三、平台对比表

| 平台 | 代表模型 | 免费额度 | API 兼容性 | 速度 | 推荐指数 |
|------|----------|----------|------------|------|----------|
| **Google AI Studio** | Gemini 2.5 Flash | 14,400 req/天（Gemma） | 专用 SDK | 快 | ★★★★★ |
| **Groq** | Llama 3.3 70B | 1,000-14,400 req/天 | OpenAI 兼容 | 极快 | ★★★★★ |
| **OpenRouter** | 30+ 免费模型 | 50 req/天 | OpenAI 兼容 | 中等 | ★★★★☆ |
| **Mistral** | Mistral Small/Large | 10 亿 tokens/月 | OpenAI 兼容 | 快 | ★★★★☆ |
| **Cerebras** | Qwen 3 235B | 30 req/分钟 | OpenAI 兼容 | 极快 | ★★★★☆ |
| **SambaNova** | DeepSeek R1 | $5 试用 | OpenAI 兼容 | 快 | ★★★☆☆ |
| **GitHub Models** | GPT-4o Mini | 按 Copilot 等级 | OpenAI 兼容 | 中等 | ★★★☆☆ |
| **HuggingFace** | 开源模型 | $0.10/月 | 专用 SDK | 慢 | ★★★☆☆ |
| **Cloudflare Workers AI** | Llama 3.1 8B | 10,000 neurons/天 | OpenAI 兼容 | 快 | ★★★☆☆ |
| **Vercel AI Gateway** | 多供应商路由 | $5/月 | OpenAI 兼容 | 取决于后端 | ★★☆☆☆ |
| **阿里云百炼** | Qwen 3 / Qwen 2.5 | 100 万 tokens/模型 | OpenAI 兼容 | 快 | ★★★★☆ |

---

## 四、最佳实践与注意事项

### 1. API Key 安全管理

永远不要将 API Key 硬编码在代码中。推荐做法：

```bash
# 写入 .env 文件（并将 .env 加入 .gitignore）
echo 'GROQ_API_KEY=gsk_xxx' >> .env
echo 'CEREBRAS_API_KEY=csk_xxx' >> .env

# Python 中使用 python-dotenv 加载
# pip install python-dotenv
```

```python
from dotenv import load_dotenv
load_dotenv()  # 自动从 .env 加载环境变量
```

### 2. 速率限制处理

免费 API 的限流是常态。推荐使用指数退避策略：

```python
import time
from openai import RateLimitError

def call_with_backoff(func, max_retries: int = 5):
    for attempt in range(max_retries):
        try:
            return func()
        except RateLimitError:
            wait = min(2 ** attempt, 60)  # 最长等 60s
            print(f"限流，{wait}s 后重试...")
            time.sleep(wait)
    raise RuntimeError("重试次数用尽")
```

### 3. 数据隐私注意

部分平台的免费版会将你的数据用于模型训练，特别注意：

- **Google AI Studio**：UK/CH/EEA/EU 以外地区数据可能用于训练
- **Mistral 免费版**：需同意数据训练条款
- **涉及敏感数据时**：优先选择明确承诺不用数据训练的平台，或使用付费版

### 4. Token 用量监控

免费额度有限，建议主动监控用量：

```python
response = client.chat.completions.create(
    model="llama-3.3-70b-versatile",
    messages=messages,
)

# 大多数平台会返回 usage 信息
if response.usage:
    print(f"输入 tokens: {response.usage.prompt_tokens}")
    print(f"输出 tokens: {response.usage.completion_tokens}")
    print(f"总计 tokens: {response.usage.total_tokens}")
```

### 5. 多平台轮换策略

对于生产级应用，建议：

- **日常开发测试**：使用 Groq（速度快）或阿里云百炼（国内直连）
- **大量批处理**：使用 Mistral（10 亿 tokens/月额度最大）
- **模型多样性**：使用 OpenRouter（30+ 模型可选）
- **代码生成场景**：使用 Mistral Codestral
- **音频转写**：使用 Groq Whisper（免费且极快）

建议同时注册 3-5 个平台的 API Key，配合本文的 `FreeLLMClient` 封装使用，即使单个平台配额耗尽也能无缝切换，实现真正的零成本 LLM 开发。

---

## 总结

免费 LLM API 生态在 2026 年已经足够成熟，足以支撑从原型验证到中小规模应用的全流程。本文梳理的 11 个平台覆盖了不同的使用场景：Google AI Studio 和 Mistral 提供最大的免费额度，Groq 和 Cerebras 提供最快的推理速度，OpenRouter 提供最丰富的模型选择，阿里云百炼则是国内开发者的最佳选择。

配合统一的 Python 封装和自动 fallback 机制，你可以将这些零散的免费资源整合成一个可靠的 LLM 调用基础设施。去注册几个 API Key，开始构建你的 AI 应用吧。