国内调用 Claude API 完整方案：Python / Node.js / Go 三语言代码示例（2026 实测）

本文介绍了在国内调用Claude API的方法，只需将请求地址替换为国内可访问的接入点https://gw.claudeapi.com。文章提供了Python、Node.js和Go三种语言的SDK安装及配置方式，包含环境变量设置和基础调用示例。同时介绍了Claude API的四个可用模型及其定价，并展示了如何实现流式响应输出。关键点在于保持原有API格式不变，仅修改请求地址即可在国内使用Claud

故乡de云

375人浏览 · 2026-04-25 14:58:08

故乡de云 · 2026-04-25 14:58:08 发布

前言

国内调用 Claude API 只需解决一个问题：把请求地址从官方的
api.anthropic.com 换成国内可访问的接入点。

API 格式、SDK 用法、参数名称全部不变，只改这一行：

ANTHROPIC_BASE_URL=https://gw.claudeapi.com

环境准备

安装 SDK

# Python
pip install anthropic python-dotenv

# Node.js
npm install @anthropic-ai/sdk dotenv

# Go
go get github.com/anthropics/anthropic-sdk-go

配置 .env

在这里插入图片描述

三种语言共用同一份环境变量文件：

# .env
ANTHROPIC_API_KEY=sk-你的ClaudeAPI密钥
ANTHROPIC_BASE_URL=https://gw.claudeapi.com

安全提示：.env 加入 .gitignore，不要提交到代码仓库。

可用模型

模型 ID	定位	输入价格	输出价格
`claude-opus-4-7`	最强推理，复杂任务	$4.0/1M	$20.0/1M
`claude-opus-4-6`	复杂推理，长上下文	$4.0/1M	$20.0/1M
`claude-sonnet-4-6`	通用开发，日常首选	$2.4/1M	$12.0/1M
`claude-haiku-4-5-20251001`	轻量快速响应	$0.8/1M	$4.0/1M

一、基础调用

Python

import os
import anthropic
from dotenv import load_dotenv

load_dotenv()

client = anthropic.Anthropic(
    api_key=os.environ["ANTHROPIC_API_KEY"],
    base_url=os.environ.get("ANTHROPIC_BASE_URL", "https://gw.claudeapi.com"),
)

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "用 Python 实现二分查找，加上注释"}
    ],
)

print(response.content[0].text)
print(f"\n用量 → 输入: {response.usage.input_tokens} tokens，"
      f"输出: {response.usage.output_tokens} tokens")

在这里插入图片描述

Node.js

import Anthropic from "@anthropic-ai/sdk";
import "dotenv/config";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  baseURL: process.env.ANTHROPIC_BASE_URL ?? "https://gw.claudeapi.com",
});

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "用 JavaScript 实现二分查找，加上注释" },
  ],
});

console.log(response.content[0].text);
console.log(`\n用量 → 输入: ${response.usage.input_tokens} tokens，`
          + `输出: ${response.usage.output_tokens} tokens`);

Go

package main

import (
    "context"
    "fmt"
    "os"

    anthropic "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/option"
)

func main() {
    client := anthropic.NewClient(
        option.WithAPIKey(os.Getenv("ANTHROPIC_API_KEY")),
        option.WithBaseURL(os.Getenv("ANTHROPIC_BASE_URL")),
    )

    response, err := client.Messages.New(context.Background(),
        anthropic.MessageNewParams{
            Model:     anthropic.F(anthropic.ModelClaudeSonnet46),
            MaxTokens: anthropic.F(int64(1024)),
            Messages: anthropic.F([]anthropic.MessageParam{
                anthropic.UserMessageParam(
                    anthropic.NewTextBlock("用 Go 实现二分查找，加上注释"),
                ),
            }),
        },
    )
    if err != nil {
        panic(err)
    }

    fmt.Println(response.Content[0].Text)
    fmt.Printf("\n用量 → 输入: %d tokens，输出: %d tokens\n",
        response.Usage.InputTokens, response.Usage.OutputTokens)
}

二、流式响应（Streaming）

面向用户的产品场景几乎都需要流式输出，避免长时间白屏等待。

Python

import os
import anthropic
from dotenv import load_dotenv

load_dotenv()

client = anthropic.Anthropic(
    api_key=os.environ["ANTHROPIC_API_KEY"],
    base_url="https://gw.claudeapi.com",
)

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    messages=[{"role": "user", "content": "详细讲解 Python 的 GIL 机制"}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
print()

Node.js

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  baseURL: "https://gw.claudeapi.com",
});

const stream = await client.messages.stream({
  model: "claude-sonnet-4-6",
  max_tokens: 2048,
  messages: [{ role: "user", content: "详细讲解 JavaScript 的事件循环" }],
});

for await (const chunk of stream) {
  if (
    chunk.type === "content_block_delta" &&
    chunk.delta.type === "text_delta"
  ) {
    process.stdout.write(chunk.delta.text);
  }
}

Go

package main

import (
    "context"
    "fmt"
    "os"

    anthropic "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/option"
)

func main() {
    client := anthropic.NewClient(
        option.WithAPIKey(os.Getenv("ANTHROPIC_API_KEY")),
        option.WithBaseURL(os.Getenv("ANTHROPIC_BASE_URL")),
    )

    stream := client.Messages.NewStreaming(context.Background(),
        anthropic.MessageNewParams{
            Model:     anthropic.F(anthropic.ModelClaudeSonnet46),
            MaxTokens: anthropic.F(int64(2048)),
            Messages: anthropic.F([]anthropic.MessageParam{
                anthropic.UserMessageParam(
                    anthropic.NewTextBlock("详细讲解 Go 的 goroutine 调度机制"),
                ),
            }),
        },
    )

    for stream.Next() {
        event := stream.Current()
        if delta, ok := event.Delta.(anthropic.ContentBlockDeltaEventDelta); ok {
            if delta.Type == "text_delta" {
                fmt.Print(delta.Text)
            }
        }
    }
    if err := stream.Err(); err != nil {
        panic(err)
    }
    fmt.Println()
}

三、多轮对话

Claude API 无状态，多轮对话需在客户端维护完整 messages 数组。

Python

import os
import anthropic
from dotenv import load_dotenv

load_dotenv()

client = anthropic.Anthropic(
    api_key=os.environ["ANTHROPIC_API_KEY"],
    base_url="https://gw.claudeapi.com",
)

history = []

def chat(user_input: str, system: str = None) -> str:
    history.append({"role": "user", "content": user_input})

    kwargs = {
        "model": "claude-sonnet-4-6",
        "max_tokens": 2048,
        "messages": history,
    }
    if system:
        kwargs["system"] = system

    response = client.messages.create(**kwargs)
    reply = response.content[0].text
    history.append({"role": "assistant", "content": reply})
    return reply

# 示例对话
system = "你是一个资深 Go 工程师，回答简洁，代码优先。"
print(chat("channel 和 mutex 分别适合什么场景？", system))
print(chat("给我一个 channel 的实际使用例子"))
print(chat("如果要限制并发数量，用哪种方式更好？"))

Node.js

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  baseURL: "https://gw.claudeapi.com",
});

const history = [];

async function chat(userInput, system = null) {
  history.push({ role: "user", content: userInput });

  const params = {
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    messages: history,
  };
  if (system) params.system = system;

  const response = await client.messages.create(params);
  const reply = response.content[0].text;
  history.push({ role: "assistant", content: reply });
  return reply;
}

// 示例对话
const system = "你是一个资深 Node.js 工程师，回答简洁，代码优先。";
console.log(await chat("Promise 和 async/await 有什么本质区别？", system));
console.log(await chat("给我一个容易踩坑的实际例子"));

Go

package main

import (
    "context"
    "fmt"
    "os"

    anthropic "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/option"
)

type ChatSession struct {
    client  *anthropic.Client
    history []anthropic.MessageParam
    system  string
}

func NewChatSession(system string) *ChatSession {
    client := anthropic.NewClient(
        option.WithAPIKey(os.Getenv("ANTHROPIC_API_KEY")),
        option.WithBaseURL(os.Getenv("ANTHROPIC_BASE_URL")),
    )
    return &ChatSession{client: client, system: system}
}

func (s *ChatSession) Chat(input string) (string, error) {
    s.history = append(s.history,
        anthropic.UserMessageParam(anthropic.NewTextBlock(input)))

    params := anthropic.MessageNewParams{
        Model:     anthropic.F(anthropic.ModelClaudeSonnet46),
        MaxTokens: anthropic.F(int64(2048)),
        Messages:  anthropic.F(s.history),
    }
    if s.system != "" {
        params.System = anthropic.F([]anthropic.TextBlockParam{
            {Type: anthropic.F(anthropic.TextBlockParamTypeText), Text: anthropic.F(s.system)},
        })
    }

    response, err := s.client.Messages.New(context.Background(), params)
    if err != nil {
        return "", err
    }

    reply := response.Content[0].Text
    s.history = append(s.history,
        anthropic.AssistantMessageParam(anthropic.NewTextBlock(reply)))
    return reply, nil
}

func main() {
    session := NewChatSession("你是一个资深 Go 工程师，回答简洁，代码优先。")

    questions := []string{
        "interface{} 和 any 有什么区别？",
        "给我一个实际项目中容易踩坑的例子",
        "泛型出来之后，这个问题有没有更好的解法？",
    }

    for _, q := range questions {
        fmt.Printf("Q: %s\n", q)
        reply, err := session.Chat(q)
        if err != nil {
            panic(err)
        }
        fmt.Printf("A: %s\n\n", reply)
    }
}

四、System Prompt 工程化封装

实际项目中通常需要固定 System Prompt，以下是三语言的封装示例。

Python

import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ["ANTHROPIC_API_KEY"],
    base_url="https://gw.claudeapi.com",
)

def create_assistant(system_prompt: str, model: str = "claude-sonnet-4-6"):
    """创建带固定 System Prompt 的调用函数"""
    def call(user_input: str, max_tokens: int = 2048) -> str:
        response = client.messages.create(
            model=model,
            max_tokens=max_tokens,
            system=system_prompt,
            messages=[{"role": "user", "content": user_input}],
        )
        return response.content[0].text
    return call

# 代码审查助手
code_reviewer = create_assistant(
    system_prompt="""你是代码审查专家。
- 只指出问题，不需要夸赞
- 格式：【问题】和【建议】两部分
- 若无明显问题，回复「未发现明显问题」""",
    model="claude-opus-4-7",
)

# SQL 优化助手
sql_optimizer = create_assistant(
    system_prompt="你是数据库优化专家，专注 PostgreSQL 性能调优，给出可直接执行的优化方案。"
)

print(code_reviewer("SELECT * FROM users WHERE name LIKE '%admin%'"))

Node.js

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  baseURL: "https://gw.claudeapi.com",
});

function createAssistant(systemPrompt, model = "claude-sonnet-4-6") {
  return async (userInput, maxTokens = 2048) => {
    const response = await client.messages.create({
      model,
      max_tokens: maxTokens,
      system: systemPrompt,
      messages: [{ role: "user", content: userInput }],
    });
    return response.content[0].text;
  };
}

const codeReviewer = createAssistant(
  `你是代码审查专家。
- 只指出问题，不需要夸赞
- 格式：【问题】和【建议】两部分
- 若无明显问题，回复「未发现明显问题」`,
  "claude-opus-4-7"
);

console.log(await codeReviewer("const data = eval(userInput)"));

五、错误处理

三种语言的通用重试逻辑：

Python

import time
import anthropic
from anthropic import RateLimitError, APIStatusError, APIConnectionError

def call_with_retry(client, messages, model="claude-sonnet-4-6", max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model=model,
                max_tokens=1024,
                messages=messages,
            )
        except RateLimitError:
            wait = 2 ** attempt
            print(f"限流，{wait}s 后重试...")
            time.sleep(wait)
        except APIStatusError as e:
            if e.status_code == 401:
                raise ValueError("API Key 无效") from e
            elif e.status_code == 529:
                time.sleep(5)
            else:
                raise
        except APIConnectionError:
            if attempt == max_retries - 1:
                raise
            time.sleep(2)
    raise RuntimeError(f"重试 {max_retries} 次后失败")

Node.js

async function callWithRetry(client, messages, model = "claude-sonnet-4-6", maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.messages.create({ model, max_tokens: 1024, messages });
    } catch (err) {
      if (err.status === 429) {
        const wait = 2 ** attempt * 1000;
        console.log(`限流，${wait / 1000}s 后重试...`);
        await new Promise((r) => setTimeout(r, wait));
      } else if (err.status === 401) {
        throw new Error("API Key 无效");
      } else if (err.status === 529) {
        await new Promise((r) => setTimeout(r, 5000));
      } else if (attempt === maxRetries - 1) {
        throw err;
      }
    }
  }
}

错误码速查：

错误码	原因	处理
401	Key 无效或无余额	检查 Key 和余额
429	请求频率超限	指数退避重试
529	服务过载	等待 5s 重试
网络超时	连接问题	检查 base_url，重试

六、三语言配置速查

Python
├── pip install anthropic python-dotenv
├── base_url="https://gw.claudeapi.com"
└── client = anthropic.Anthropic(api_key=..., base_url=...)

Node.js
├── npm install @anthropic-ai/sdk dotenv
├── baseURL: "https://gw.claudeapi.com"
└── new Anthropic({ apiKey: ..., baseURL: ... })

Go
├── go get github.com/anthropics/anthropic-sdk-go
├── option.WithBaseURL("https://gw.claudeapi.com")
└── anthropic.NewClient(option.WithAPIKey(...), option.WithBaseURL(...))

三篇代码均在国内网络环境下实测通过，
base_url 统一使用 https://gw.claudeapi.com，
延迟稳定在 150–200ms，可直接用于生产环境。
``