国产模型免费渠道大全

返回 🐑 羊毛福利

国产模型免费渠道大全

YiXinCoding 1

2026-04-20 03:17 · 26 次浏览 · 0 条评论 · 0 cool

国模 2API 方法大全。你只要有一台能联网的服务器，一个公网 IP

# Qwen

总结：一个 Docker 2API 项目，需要一台具有公网 IP 的服务器并将 8000 端口开放

## 部署方法

运行命令
`docker run -it -d --init --name qwen-free-api -p 8000:8000 -e TZ=Asia/Shanghai vinlic/qwen-free-api:latest`

## 使用方法

从 [通义千问](https://tongyi.aliyun.com/qianwen) 登录
进入通义千问随便发起一个对话，然后 F12 打开开发者工具，从 Application > Cookies 中找到 `tongyi_sso_ticket` 的值，这将作为 Authorization 的 Bearer Token 值。
用 Authorization 的 Bearer Token 作为 API 密钥使用 API

url：yourip:8000/v1

> 如果失效，可以使用这个项目： [GitHub - smanx/qwen2api: A proxy service that converts Qwen Chat to an OpenAI-compatible API. · GitHub](https://github.com/smanx/qwen2api)

# GLM AI

总结：一个 Docker 2API 项目，需要一台具有公网 IP 的服务器并将 8000 端口开放

## 部署方法

运行命令
`docker run -it -d --init --name glm-free-api -p 8000:8000 -e TZ=Asia/Shanghai vinlic/glm-free-api:latest`

## 使用方法

从 [智谱清言](https://chatglm.cn/) 获取 refresh_token

进入智谱清言随便发起一个对话，然后 F12 打开开发者工具，从 Application > Cookies 中找到 `chatglm_refresh_token` 的值，这将作为 Authorization 的 Bearer Token 值：`Authorization: Bearer TOKEN`

![](/images/51)

用 Authorization 的 Bearer Token 作为 API 密钥使用 API
url：yourip:8000/v1

# 讯飞星火（Spark）

总结：一个 Docker 2API 项目，需要一台具有公网 IP 的服务器并将 8000 端口开放

## 部署方法

运行命令

`docker run -it -d --init --name spark-free-api -p 8000:8000 -e TZ=Asia/Shanghai vinlic/spark-free-api:latest`

## 使用方法

从 [xinghuo.xfyun.cn](https://xinghuo.xfyun.cn/) 获取 ssoSessionId, 进入 Spark 登录并发起一个对话，从 Cookie 获取 `ssoSessionId` 值，由于星火平台禁用 F12 开发者工具，请安装 `Cookie-Editor` 浏览器插件查看你的 Cookie。

这个值将作为 Authorization 的 Bearer Token 值：`Authorization: Bearer TOKEN`

**注意：如果退出登录或重新登录将可能导致 ssoSessionId 失效！**

### 智能体接入

从[这里](https://xinghuo.xfyun.cn/iflygpt/bot/home/get)使用浏览器搜索功能找到你想要的智能体，复制它的 `botId` 作为 `model` 值。

### 多账号接入

你可以通过提供多个账号的 ssoSessionId 并使用 `,` 拼接提供：

`Authorization: Bearer TOKEN1,TOKEN2,TOKEN3`

用 Authorization 的 Bearer Token 作为 API 密钥使用 API

url：yourip:8000/v1

# DeepSeek

## 部署方法

运行命令

```
docker run -it -d --init --name deepseek-free-api -p 8000:8000 -e TZ=Asia/Shanghai vinlic/deepseek-free-api:latest # 或将token配置在环境变量 docker run -it -d --init --name deepseek-free-api -p 8000:8000 -e TZ=Asia/Shanghai -e DEEP_SEEK_CHAT_AUTHORIZATION=xxx vinlic/deepseek-free-api:latest
```

## 使用方法

从 [DeepSeek](https://chat.deepseek.com/) 获取 userToken value

进入 DeepSeek 随便发起一个对话，然后 F12 打开开发者工具，从 Application > LocalStorage 中找到 `userToken` 中的 value 值，这将作为 Authorization 的 Bearer Token 值：`Authorization: Bearer TOKEN`
用 Authorization 的 Bearer Token 作为 API 密钥使用 API

### 多账号接入

目前同个账号同时只能有*一路*输出，你可以通过提供多个账号的 userToken value 并使用 `,` 拼接提供：

`Authorization: Bearer TOKEN1,TOKEN2,TOKEN3`

每次请求服务会从中挑选一个。

### 环境变量（可选）

|环境变量|是否必填|说明|
| --- | --- | --- |
|DEEP_SEEK_CHAT_AUTHORIZATION|否|当配置了 token 则使用 token，未配置则需要在请求头中传递 Authorization|
|url：yourip:8000/v1|||

如果失效，可以用这个项目：[GitHub - CJackHwang/ds2api: Deepseek to API - 客户端转 API 全栈开源工具，高性能，多账号轮询，支持纯 vercel、docker 部署使用。Google、Claude、ChatGPT 多接口格式兼容・GitHub](https://github.com/CJackHwang/ds2api)

# DouBao

没研究过，可以参考以下项目：[GitHub - lza6/doubao-2api: 无头浏览器 (Playwright) 逆向 a_bogus 风控签名、静态设备指纹、动态 msToken 刷新、高级反检测伪装 (playwright-stealth)、需自备 Cookie (支持多账号轮询)、兼容 OpenAI 格式 API、原生流式输出、有状态会话保持、Docker 一键部署・GitHub](https://github.com/lza6/doubao-2api)

# Kimi

## 总结

Cloudflare Worker 脚本。

## 部署方法

新建一个 Cloudflare Workers，输入以下代码

```js
// Cloudflare Worker - Kimi K2 OpenAI API 兼容代理
// 环境变量: UPSTREAM_HOST (可选，默认 https://kimi-k2.ai)

const DEFAULT_UPSTREAM_HOST = "https://kimi-k2.ai";

/**
 * 生成随机 IP 地址
 * 使用常见的住宅/商业 IP 段，避免数据中心 IP 段
 */
function generateRandomIP() {
  // 常见的住宅/商业 IP 段前缀 (中国和国际)
  const ipPrefixes = [
    // 中国电信
    [113, 116], [114, 80], [115, 192], [116, 224], [117, 136],
    [118, 112], [119, 96], [120, 192], [121, 32], [122, 192],
    // 中国联通
    [112, 64], [113, 0], [116, 112], [119, 112], [120, 64],
    // 中国移动
    [111, 0], [112, 0], [117, 128], [120, 128], [183, 192],
    // 美国常见段
    [24, 0], [50, 0], [68, 0], [71, 0], [72, 0], [73, 0],
    [76, 0], [96, 0], [98, 0], [99, 0], [107, 0], [108, 0]
  ];

const prefix = ipPrefixes[Math.floor(Math.random() * ipPrefixes.length)];
  const octet3 = Math.floor(Math.random() * 256);
  const octet4 = Math.floor(Math.random() * 254) + 1; // 避免 0 和 255

return `${prefix[0]}.${prefix[1] + Math.floor(Math.random() * 16)}.${octet3}.${octet4}`;
}

/**
 * 生成包含伪造 IP 的请求头
 */
function generateSpoofedHeaders(baseHeaders = {}) {
  const fakeIP = generateRandomIP();
  console.log(`[IP伪造] 使用伪造 IP: ${fakeIP}`);

return {
    ...baseHeaders,
    "X-Forwarded-For": fakeIP,
    "X-Real-IP": fakeIP,
    "CF-Connecting-IP": fakeIP,
    "X-Originating-IP": fakeIP,
    "True-Client-IP": fakeIP,
    "X-Client-IP": fakeIP,
    "Forwarded": `for=${fakeIP}`
  };
}

/**
 * 获取认证 Cookies
 */
async function getAuthCookies(upstreamHost) {
  console.log("[认证] 正在尝试获取认证 Cookies...");

const headers = generateSpoofedHeaders({
    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
    "accept": "*/*",
    "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
    "referer": `${upstreamHost}/zh/chat`
  });

const response = await fetch(`${upstreamHost}/api/auth/session`, { headers });
  console.log(`[认证] 收到上游 Cookies 响应, 状态码: ${response.status}`);

const cookies = response.headers.get("set-cookie");
  if (!cookies) {
    console.error("[认证] 错误: 未在响应头中找到 'set-cookie'");
    return null;
  }

const csrfMatch = cookies.match(/__Host-authjs\.csrf-token=([^;]+)/);
  const callbackMatch = cookies.match(/__Secure-authjs\.callback-url=([^;]+)/);

const authData = {
    csrf: csrfMatch ? csrfMatch[1] : null,
    callback: callbackMatch ? callbackMatch[1] : null
  };

if (authData.csrf && authData.callback) {
    console.log("[认证] 成功解析 CSRF 和 Callback Cookies");
  } else {
    console.warn("[认证] 警告: 未能完整解析 Cookies:", authData);
  }

return authData;
}

/**
 * 生成 Session ID
 */
function generateSessionId() {
  const sessionId = crypto.randomUUID();
  console.log(`[工具] 生成新的 Session ID: ${sessionId}`);
  return sessionId;
}

/**
 * 将 OpenAI 格式请求转换为上游格式
 */
function convertToUpstreamFormat(openaiRequest) {
  console.log("[转换] 正在将 OpenAI 格式转换为上游格式...");
  return {
    messages: openaiRequest.messages,
    sessionId: generateSessionId(),
    searchContext: ""
  };
}

/**
 * 将上游响应转换为 OpenAI 格式
 */
function convertToOpenAIFormat(upstreamResponse, model, stream = false) {
  const id = `chatcmpl-${Date.now()}`;
  const created = Math.floor(Date.now() / 1000);

if (stream) {
    console.log("[转换] 正在将上游响应转换为 OpenAI 流式格式...");
    const chunk = {
      id,
      object: "chat.completion.chunk",
      created,
      model,
      choices: [{
        index: 0,
        delta: { content: upstreamResponse.content },
        finish_reason: "stop"
      }]
    };
    return `data: ${JSON.stringify(chunk)}\n\ndata: [DONE]\n\n`;
  }

console.log("[转换] 正在将上游响应转换为 OpenAI JSON 格式...");
  return {
    id,
    object: "chat.completion",
    created,
    model,
    choices: [{
      index: 0,
      message: {
        role: "assistant",
        content: upstreamResponse.content
      },
      finish_reason: "stop"
    }],
    usage: upstreamResponse.usage || {
      prompt_tokens: 0,
      completion_tokens: 0,
      total_tokens: 0
    }
  };
}

/**
 * 处理聊天完成请求
 */
async function handleChatCompletion(request, upstreamHost) {
  console.log("[聊天处理] 开始处理 /v1/chat/completions 请求...");
  const openaiRequest = await request.json();
  const stream = openaiRequest.stream === true;
  const model = openaiRequest.model || "kimi-k2";
  console.log(`[聊天处理] 请求参数: 模型=${model}, 是否流式=${stream}`);

const upstreamRequest = convertToUpstreamFormat(openaiRequest);
  console.log(`[聊天处理] 准备向上游 ${upstreamHost}/api/chat 发送请求`);

const upstreamResponse = await fetch(`${upstreamHost}/api/chat`, {
    method: "POST",
    headers: chatHeaders,
    body: JSON.stringify(upstreamRequest)
  });

console.log(`[聊天处理] 收到上游响应, 状态码: ${upstreamResponse.status}`);

if (!upstreamResponse.ok) {
    console.error(`[聊天处理] 错误: 上游请求失败, 状态码: ${upstreamResponse.status}`);
    return new Response(JSON.stringify({ error: "Upstream request failed" }), {
      status: upstreamResponse.status,
      headers: { "content-type": "application/json" }
    });
  }

const upstreamData = await upstreamResponse.json();
  console.log("[聊天处理] 成功解析上游 JSON 响应");

if (stream) {
    console.log("[聊天处理] 正在以流式 (SSE) 格式返回响应");
    const streamData = convertToOpenAIFormat(upstreamData, model, true);
    return new Response(streamData, {
      headers: {
        "content-type": "text/event-stream",
        "cache-control": "no-cache",
        "connection": "keep-alive"
      }
    });
  }

console.log("[聊天处理] 正在以 JSON 格式返回响应");
  const openaiResponse = convertToOpenAIFormat(upstreamData, model, false);
  return new Response(JSON.stringify(openaiResponse), {
    headers: { "content-type": "application/json" }
  });
}

/**
 * 添加 CORS 响应头
 */
function addCorsHeaders(response) {
  const newHeaders = new Headers(response.headers);
  newHeaders.set("Access-Control-Allow-Origin", "*");
  newHeaders.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
  newHeaders.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
  return new Response(response.body, {
    status: response.status,
    statusText: response.statusText,
    headers: newHeaders
  });
}

/**
 * 主请求处理函数
 */
async function handleRequest(request, env) {
  const upstreamHost = env.UPSTREAM_HOST || DEFAULT_UPSTREAM_HOST;
  const url = new URL(request.url);
  console.log(`[入口] 收到新请求: ${request.method} ${url.pathname}`);

// 处理 CORS 预检请求
  if (request.method === "OPTIONS") {
    return new Response(null, {
      headers: {
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
        "Access-Control-Allow-Headers": "Content-Type, Authorization",
        "Access-Control-Max-Age": "86400"
      }
    });
  }

let response;

// 健康检查端点
  if (url.pathname === "/health" && request.method === "GET") {
    console.log("[路由] 匹配到: /health (GET)");
    response = new Response(JSON.stringify({
      status: "healthy",
      timestamp: new Date().toISOString(),
      upstreamHost: upstreamHost
    }), {
      headers: { "content-type": "application/json" }
    });
    return addCorsHeaders(response);
  }

// 聊天完成端点
  if (url.pathname === "/v1/chat/completions" && request.method === "POST") {
    console.log("[路由] 匹配到: /v1/chat/completions (POST)");
    response = await handleChatCompletion(request, upstreamHost);
    return addCorsHeaders(response);
  }

// 模型列表端点
  if (url.pathname === "/v1/models" && request.method === "GET") {
    console.log("[路由] 匹配到: /v1/models (GET)");
    response = new Response(JSON.stringify({
      object: "list",
      data: [{
        id: "kimi-k2",
        object: "model",
        created: Math.floor(Date.now() / 1000),
        owned_by: "kimi"
      }]
    }), {
      headers: { "content-type": "application/json" }
    });
    return addCorsHeaders(response);
  }

console.log(`[路由] 未找到匹配路由: ${url.pathname}, 返回 404`);
  return new Response("Not Found", { status: 404 });
}

// Cloudflare Worker 导出
export default {
  async fetch(request, env, ctx) {
    return handleRequest(request, env);
  }
};
```

## 使用方法

API 密钥随便填（不会用的请先学一下其他帖子）

# Other

这有一些其他项目，早已失效 / 太冷门，可以拿去`氛围式编程`试一下。
Moonshot AI（Kimi.ai）接口转 API [kimi-free-api](https://github.com/LLM-Red-Team/kimi-free-api)

阶跃星辰 (跃问 StepChat) 接口转 API [step-free-api](https://github.com/LLM-Red-Team/step-free-api)

秘塔 AI (Metaso) 接口转 API [metaso-free-api](https://github.com/LLM-Red-Team/metaso-free-api) （当前不可用）

字节跳动（豆包）接口转 API [doubao-free-api](https://github.com/LLM-Red-Team/doubao-free-api) （当前不可用）

字节跳动（即梦 AI）接口转 API [jimeng-free-api](https://github.com/LLM-Red-Team/jimeng-free-api)

讯飞星火（Spark）接口转 API [spark-free-api](https://github.com/LLM-Red-Team/spark-free-api)

MiniMax（海螺 AI）接口转 API [hailuo-free-api](https://github.com/LLM-Red-Team/hailuo-free-api)

<del>聆</del><del>心</del><del>智</del><del>能</del> <del>(</del><del>Emohaa</del><del>)</del> <del>接</del><del>口</del><del>转</del> <del>API </del>[<del>emohaa</del><del>-</del><del>free</del><del>-</del><del>api</del>](https://github.com/LLM-Red-Team/emohaa-free-api)<del>（</del><del>当</del><del>前</del><del>不</del><del>可</del><del>用</del><del>）</del>

转载查看原文

0 cool

暂无评论，来说两句吧

登录后评论

系统节点

兴趣节点全部

国产模型免费渠道大全

评论 (0)

系统节点

兴趣节点 全部

国产模型免费渠道大全

评论 (0)

兴趣节点全部