How to Configure Claude Agent SDK: Complete Setup Guide

To configure the Claude Agent SDK, set three environment variables: ANTHROPIC_API_KEY for authentication, ANTHROPIC_BASE_URL for your API endpoint, and ANTHROPIC_MODEL for model selection. Install the SDK with npm install @anthropic-ai/sdk, create a .env file with these variables, and you're ready to build AI agents in under 5 minutes.

This guide covers the complete setup process — from installation to production deployment — with working code examples, environment variable references, and troubleshooting for common errors.

---

If you've been following the rapid evolution of AI development tools, you already know that Claude Code and the Claude Agent SDK represent some of the most exciting infrastructure available to developers today. But getting started shouldn't require hours of documentation spelunking or complex credential juggling.

Thanks to a brilliantly simple tip from @idoubicc on X, there's a clean, three-line configuration pattern that connects Claude Code (CC) and the Claude Agent SDK using environment variables — making integration fast, reproducible, and production-friendly.

In this guide, we'll break down exactly what each line does, why it matters, and how you can extend this minimal setup into a full-featured AI automation workflow on ClawList.io.

---

Quick Answer: Configure Claude Agent SDK in 3 Steps

For developers who want the answer fast:

Step 1: Install the SDK.

npm install @anthropic-ai/sdk dotenv

Step 2: Create a .env file with three variables.

ANTHROPIC_API_KEY=sk-ant-your-key-here
ANTHROPIC_BASE_URL=https://api.anthropic.com
ANTHROPIC_MODEL=claude-sonnet-4-20250514

Step 3: Initialize the client in your code.

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

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  baseURL: process.env.ANTHROPIC_BASE_URL,
});

That's the entire setup. The rest of this guide explains each piece in depth, covers advanced configurations, and helps you debug issues when they arise.

---

Why Minimal Configuration Matters for AI SDK Integration

Before we dive into the code, let's talk about why a three-line configuration is such a big deal.

Modern AI agent frameworks tend to accumulate complexity quickly. Authentication layers, model routing, base URL management, environment parity — each of these concerns adds cognitive overhead and potential failure points. When you're building an OpenClaw skill or prototyping an automation pipeline, the last thing you want is to spend 45 minutes debugging environment setup before writing a single line of business logic.

The pattern shared by @idoubicc solves this elegantly by leveraging three standard environment variables that the Claude Agent SDK already knows how to consume:

• Authentication — who you are
• Base URL — where to send requests
• Model selection — what to run

That's it. Three variables, one coherent setup, infinite possibilities.

---

Prerequisites

Before you begin, make sure you have:

• Node.js 18+ installed (check with node -v)
• An Anthropic API key from console.anthropic.com
• A terminal and a text editor

For Python users, you'll also need Python 3.9+ and pip.

---

Installation

Node.js / TypeScript

# Create a new project (optional)
mkdir claude-agent-demo && cd claude-agent-demo
npm init -y

# Install the SDK and dotenv
npm install @anthropic-ai/sdk dotenv

Python

pip install anthropic python-dotenv

Verify Installation

# Node.js
node -e "console.log(require.resolve('@anthropic-ai/sdk'))"

# Python
python -c "import anthropic; print('SDK installed successfully')"

---

Environment Variables Reference

| Variable | Required | Default | Description | |----------|----------|---------|-------------| | ANTHROPIC_API_KEY | Yes | None | Your Anthropic API key (starts with sk-ant-) | | ANTHROPIC_BASE_URL | No | https://api.anthropic.com | API endpoint URL. Override for proxies, gateways, or regional endpoints | | ANTHROPIC_MODEL | No | claude-sonnet-4-20250514 | Model identifier for completions | | ANTHROPIC_AUTH_TOKEN | No | None | Alternative auth header (some providers use this instead of API_KEY) | | ANTHROPIC_MAX_TOKENS | No | 4096 | Default max tokens per response | | ANTHROPIC_TIMEOUT | No | 60000 | Request timeout in milliseconds |

Tip: Never commit .env files to version control. Add .env to your .gitignore immediately after creating it.

---

The Three-Line Configuration Explained

Here's the core configuration pattern:

ANTHROPIC_AUTH_TOKEN="<ARK_API_KEY>"
ANTHROPIC_BASE_URL="https://ark.cn-beijing.volces.com/api/v3/bots"
ANTHROPIC_MODEL="ark-code-latest"

Let's unpack each line individually.

ANTHROPIC_AUTH_TOKEN

ANTHROPIC_AUTH_TOKEN="<ARK_API_KEY>"

This is your authentication credential — replace <ARK_API_KEY> with your actual ARK API key. The Claude Agent SDK uses this token to verify your identity and authorize API calls. Using an environment variable here (rather than hardcoding the key) is not just a best practice — it's essential for:

• Keeping secrets out of version control
• Supporting multiple deployment environments (dev, staging, prod)
• Enabling seamless CI/CD integration

If you're working on a ClawList.io OpenClaw skill, this is the token you'd register in your skill's secure credential store.

ANTHROPIC_BASE_URL

ANTHROPIC_BASE_URL="https://ark.cn-beijing.volces.com/api/v3/bots"

This variable tells the SDK where to route its API requests. By default, the Anthropic SDK points to Anthropic's official endpoints. Overriding the base URL allows you to:

• Route through a proxy or gateway for compliance or cost management
• Use regional endpoints for lower latency (this example uses a Beijing-region ARK endpoint)
• Swap backends without touching application code — perfect for testing or multi-provider setups

This flexibility is one of the most underrated aspects of the SDK's design. For enterprise developers and teams working with AI automation at scale, controlling where traffic flows is critical for both performance and governance.

ANTHROPIC_MODEL

ANTHROPIC_MODEL="ark-code-latest"

This specifies the model variant the SDK should use for completions and agent tasks. ark-code-latest is a code-optimized model, making it ideal for:

• Code generation and review tasks
• Automated debugging pipelines
• Developer tooling and IDE integrations
• Technical documentation generation

Pinning your model name to an environment variable (rather than hardcoding it in each API call) gives you the ability to upgrade or swap models across your entire application by changing a single value — no code changes required.

---

Putting It All Together: Node.js Example

Here's how you'd wire this configuration into a Node.js project using the Claude Agent SDK:

// .env file (never commit this!)
// ANTHROPIC_API_KEY=sk-ant-your-key-here
// ANTHROPIC_BASE_URL=https://api.anthropic.com
// ANTHROPIC_MODEL=claude-sonnet-4-20250514

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

dotenv.config();

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  baseURL: process.env.ANTHROPIC_BASE_URL,
});

const model = process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514";

async function runCodeAgent(prompt) {
  const response = await client.messages.create({
    model: model,
    max_tokens: 2048,
    messages: [
      {
        role: "user",
        content: prompt,
      },
    ],
  });

  return response.content[0].text;
}

// Example usage
const result = await runCodeAgent(
  "Write a Python function that parses JSON and handles errors gracefully."
);

console.log(result);

With just this setup, you have a fully functional Claude Code agent that's environment-aware, credential-safe, and ready for deployment.

---

Python Example

For Python developers, the equivalent setup looks like this:

import anthropic
import os
from dotenv import load_dotenv

load_dotenv()

client = anthropic.Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
    base_url=os.environ.get("ANTHROPIC_BASE_URL"),
)

model = os.environ.get("ANTHROPIC_MODEL", "claude-sonnet-4-20250514")

def run_code_agent(prompt: str) -> str:
    message = client.messages.create(
        model=model,
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}],
    )
    return message.content[0].text

# Test it
output = run_code_agent("Explain async/await in JavaScript with examples.")
print(output)

---

Common Errors and Troubleshooting

| Error | Cause | Solution | |-------|-------|----------| | AuthenticationError: Invalid API key | API key is missing, expired, or malformed | Regenerate your key at console.anthropic.com and update your .env file | | ConnectionRefused or ECONNREFUSED | ANTHROPIC_BASE_URL is unreachable | Verify the URL is correct and your network allows outbound HTTPS. Test with curl $ANTHROPIC_BASE_URL | | RateLimitError: 429 | Too many requests in a short window | Add exponential backoff or reduce request frequency. See the retry example below | | Model not found | ANTHROPIC_MODEL value doesn't match an available model | Check available models at docs.anthropic.com | | Module not found: @anthropic-ai/sdk | SDK not installed | Run npm install @anthropic-ai/sdk or pip install anthropic | | TimeoutError | Request took too long | Increase ANTHROPIC_TIMEOUT or reduce max_tokens |

Adding Retry Logic

async function runWithRetry(prompt, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await runCodeAgent(prompt);
    } catch (err) {
      if (err.status === 429 && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Rate limited. Retrying in ${delay / 1000}s...`);
        await new Promise(r => setTimeout(r, delay));
      } else {
        throw err;
      }
    }
  }
}

---

Using a Custom Provider or Proxy

Many teams route Claude API calls through a proxy for logging, cost tracking, or compliance. Here's how to configure it:

# Route through a corporate proxy
ANTHROPIC_BASE_URL=https://ai-gateway.internal.company.com/anthropic/v1

# Or use a regional endpoint
ANTHROPIC_BASE_URL=https://ark.cn-beijing.volces.com/api/v3/bots

The SDK treats ANTHROPIC_BASE_URL as a drop-in replacement — all endpoints, headers, and request formats remain the same. This makes it trivial to switch between providers or environments without changing a single line of application code.

For teams building long-running agent workflows with Manus, routing through a gateway also enables session persistence and request queuing across distributed workers.

---

Real-World Use Cases for This Configuration

This minimal setup unlocks a surprising range of applications:

• OpenClaw Skills on ClawList.io — Build and deploy AI automation skills with clean, swappable credentials
• Code Review Bots — Integrate into GitHub Actions or GitLab CI to review PRs automatically
• Documentation Generators — Auto-generate technical docs from source code comments
• Developer Copilots — Power internal tools that assist with boilerplate, refactoring, or debugging
• Multi-Environment Pipelines — Use different models or endpoints per environment without code changes

The beauty of environment-variable-driven configuration is that the same application code runs seamlessly across local development, staging, and production — you're just swapping the .env file or the secrets manager entries.

For a deeper dive into how agent architectures handle configuration, skill loading, and runtime context, see the OpenClaw 9-Layer System Prompt Architecture breakdown.

---

Using Environment Variables in CI/CD Pipelines

In production, you should never store API keys in .env files on disk. Instead, inject them at runtime through your CI/CD platform's secret management:

GitHub Actions:

jobs:
  deploy:
    steps:
      - name: Run agent
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          ANTHROPIC_BASE_URL: ${{ secrets.ANTHROPIC_BASE_URL }}
          ANTHROPIC_MODEL: claude-sonnet-4-20250514
        run: node agent.js

Docker:

docker run -e ANTHROPIC_API_KEY -e ANTHROPIC_BASE_URL -e ANTHROPIC_MODEL my-agent-image

Vercel / Netlify: Add environment variables in the project dashboard under Settings > Environment Variables. They'll be available as process.env in serverless functions.

This approach keeps secrets out of your codebase entirely and lets you rotate keys without redeploying code.

Streaming Responses for Real-Time UX

The Claude Agent SDK supports streaming, which is essential for chat interfaces and real-time dashboards:

async function streamAgent(prompt) {
  const stream = await client.messages.create({
    model: process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514",
    max_tokens: 2048,
    messages: [{ role: "user", content: prompt }],
    stream: true,
  });

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

Streaming reduces perceived latency by delivering tokens as they're generated, rather than waiting for the full response. This is especially important for long-running agent tasks where users need feedback that the agent is still working.

Security Best Practices

When working with API keys and the Claude Agent SDK in production, follow these security guidelines:

• Rotate keys regularly. Set a calendar reminder to regenerate your API key every 90 days.
• Use least-privilege access. If your provider supports scoped tokens, grant only the permissions your agent actually needs.
• Monitor usage. Set up billing alerts and usage dashboards to catch unexpected spikes that could indicate a compromised key or runaway agent.
• Audit logs. Enable request logging in your proxy or gateway to maintain a trail of all API calls for compliance and debugging.
• Separate keys per environment. Never share a single API key across dev, staging, and production. If one is compromised, you can revoke it without affecting other environments.

For teams managing multiple agents or skills, consider a centralized secrets manager like AWS Secrets Manager, HashiCorp Vault, or Doppler to handle key rotation and access control automatically.

Next Steps

Now that your Claude Agent SDK is configured, here's what to explore next:

• OpenClaw Node.js Tutorial — Build your first AI agent with OpenClaw from scratch
• OpenClaw 9-Layer System Prompt Architecture — Understand how agent prompts are structured in production
• Manus + Claude Code for Long-Running Tasks — Break through task duration limits with persistent agent workflows
• Building Image Generation Skills for AI Agents — Add visual capabilities to your agent toolkit
• Browse all OpenClaw Skills — Find pre-built skills to accelerate your development

---

Want more quick-start guides for Claude, OpenClaw skills, and AI automation? Explore the full resource library at ClawList.io.