Setting Up Your Environment

Before you write a line of agent code, you need three things: an API key, a safe place to keep it, and a working SDK. This page gets all three in place and ends with the same "hello, Claude" call made two different ways.

Create your Console account and generate an API key

☺ Like you're 10: Think of this like getting a library card before you're allowed to borrow anything — you need the key before Claude will say a word back to you.

Every Claude API call is authenticated with an API key issued from the Console. Go to platform.claude.com — this is now the shared home for both the Console and the docs, and the older console.anthropic.com and docs.claude.com addresses redirect here — and sign in or create an account.

Once you're in, open Settings → API keys and click Create key. You'll be asked to:

• Name the key (something like course-dev so you can tell it apart later)
• Optionally scope it to a workspace
• Choose an expiration — 3 hours, 1 day, 7 days, 30 days, a custom window, or Never for keys you'll store in a proper secrets manager and rotate yourself

Store the key as an environment variable — never hardcode it

☺ Like you're 10: It's the difference between hiding your house key under a rock only you know about, versus writing your address and key shape on a public bulletin board.

Both official SDKs, and the raw HTTP API, look for your key in the ANTHROPIC_API_KEY environment variable, so that's the one you should set. Anthropic's own authentication guidance is blunt about this: store keys in a secrets manager, set them as an environment variable, never commit them to source control, rotate them periodically, and revoke any key you suspect has leaked.

The standard local-development pattern is a .env file at your project root, loaded by a small dotenv library so the variable ends up in the process environment before your code runs.

# .env  (project root, never committed)
ANTHROPIC_API_KEY=sk-ant-api03-your-key-here

# pip install python-dotenv
from dotenv import load_dotenv
import os

load_dotenv()  # reads .env into the process environment

print("Key loaded:", os.environ["ANTHROPIC_API_KEY"][:12] + "...")

// npm install dotenv
import "dotenv/config"; // reads .env into process.env as a side effect

console.log("Key loaded:", process.env.ANTHROPIC_API_KEY?.slice(0, 12) + "...");

You can also export the variable directly in your shell for a one-off session, which is handy when testing from the terminal:

export ANTHROPIC_API_KEY="sk-ant-api03-..."

# .gitignore
.env
.env.*
__pycache__/
node_modules/

Install the SDKs

Anthropic publishes official SDKs for Python and TypeScript/JavaScript. Install whichever matches the language you're working in — you don't need both unless you're following along with every example in this course.

pip install anthropic

npm install @anthropic-ai/sdk

Both SDKs read ANTHROPIC_API_KEY from the environment automatically when you construct a bare client — no key needs to appear in your code at all.

Your first call: "hello, Claude"

☺ Like you're 10: You're mailing a letter (your question) to Claude's address, and the reply comes back in a labeled envelope so your code knows exactly what kind of thing it's holding before it reads it.

Underneath both SDKs is the same HTTP request: a POST to /v1/messages with a model, a max_tokens limit, and a messages array whose first entry has role: "user". The response comes back as a content array of typed blocks, so you check block.type == "text" before reading block.text — a response can in principle contain other block types alongside or instead of text.

Here's the identical request in Python and JavaScript. Both ask Claude the same question and print the resulting text.

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from env

message = client.messages.create(
    model="claude-opus-5",
    max_tokens=1000,
    messages=[
        {
            "role": "user",
            "content": "What should I search for to find the latest developments in renewable energy?",
        }
    ],
)

for block in message.content:
    if block.type == "text":
        print(block.text)

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

const client = new Anthropic(); // reads ANTHROPIC_API_KEY from env

const message = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 1000,
  messages: [
    {
      role: "user",
      content: "What should I search for to find the latest developments in renewable energy?"
    }
  ]
});

for (const block of message.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

Both SDKs do a few things by hand for you under the hood: they set an x-api-key header from your environment variable and add an anthropic-version header that pins the API's dated schema version. If you ever need to debug an SDK issue, knowing those two headers exist is a fast way to tell whether a problem is in your code or in the request itself.

Doing this in VS Code

☺ Like you're 10: VS Code is your workbench — this section is just where the "run" button lives for each kind of file.

This course uses VS Code as its reference editor, so it's worth knowing the couple of ways you'll typically run this code there.

Running a .py file from the integrated terminal

Save the Python snippet above as hello_claude.py, open VS Code's integrated terminal (Ctrl+` / Cmd+`), make sure the Python extension has selected the interpreter for the virtual environment where you ran pip install anthropic python-dotenv, and run:

python hello_claude.py

Using an interactive Python cell

If you have the Python extension installed, you can add a # %% comment above a block of code to turn it into a runnable Jupyter-style cell directly inside a .py file — VS Code shows a "Run Cell" link above it and opens results in the Interactive Window. This is a convenient way to iterate on a prompt and inspect message.content without re-running the whole script each time.

Running a .ts file with ts-node

For the TypeScript version, save the snippet as hello-claude.ts, install a TypeScript runner in the integrated terminal, and execute it directly:

npm install -D typescript ts-node @types/node
npx ts-node hello-claude.ts

If you'd rather skip a TypeScript-specific runner, compile with tsc and run the emitted JavaScript with plain node, or write the example directly as a .mjs file using node hello-claude.mjs.

Troubleshooting