Working with APIs

Using API keys in Python:

import os

# NEVER hardcode API keys in your source code
# Store them in environment variables instead
api_key = os.environ.get("OPENAI_API_KEY")

# The key is sent as an Authorization header
headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

# Or set it via a .env file with python-dotenv
from dotenv import load_dotenv
load_dotenv()  # Loads variables from .env file
api_key = os.environ.get("ANTHROPIC_API_KEY")

Handling rate limits gracefully:

import time
import requests

def call_api_with_retry(url, headers, data, max_retries=3):
    """Make an API call with exponential backoff on rate limits."""
    for attempt in range(max_retries):
        response = requests.post(url, headers=headers, json=data)

        if response.status_code == 200:
            return response.json()
        elif response.status_code == 429:  # Rate limited
            wait_time = 2 ** attempt  # 1s, 2s, 4s...
            print(f"Rate limited. Waiting {wait_time}s...")
            time.sleep(wait_time)
        else:
            response.raise_for_status()

    raise Exception("Max retries exceeded")

JSON request and response example:

# Sending a JSON request body (Python dict → JSON automatically)
import requests

data = {
    "model": "gpt-4o",
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain APIs in one sentence."},
    ],
    "temperature": 0.7,
    "max_tokens": 100,
}

response = requests.post(url, headers=headers, json=data)

# Parsing the JSON response (JSON → Python dict automatically)
result = response.json()

# Navigate the nested structure
message = result["choices"][0]["message"]["content"]
tokens_used = result["usage"]["total_tokens"]
print(f"Response: {message}")
print(f"Tokens used: {tokens_used}")

Making API calls with the requests library:

import requests
import os

# --- GET request: retrieve information ---
response = requests.get(
    "https://api.openai.com/v1/models",
    headers={"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"},
)
print(f"Status: {response.status_code}")  # 200 = success
models = response.json()["data"]
print(f"Available models: {len(models)}")

# --- POST request: send data and get a response ---
response = requests.post(
    "https://api.openai.com/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "gpt-4o",
        "messages": [{"role": "user", "content": "Hello!"}],
    },
)

if response.status_code == 200:
    print(response.json()["choices"][0]["message"]["content"])
else:
    print(f"Error {response.status_code}: {response.text}")

OpenAI chat completions with the official SDK:

from openai import OpenAI

client = OpenAI()  # Reads OPENAI_API_KEY from environment

# Basic chat completion
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful coding tutor."},
        {"role": "user", "content": "Explain list comprehensions in Python."},
    ],
    temperature=0.7,
    max_tokens=500,
)

print(response.choices[0].message.content)
print(f"Tokens used: {response.usage.total_tokens}")

OpenAI function calling:

from openai import OpenAI
import json

client = OpenAI()

# Define tools the model can use
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and state, e.g. Austin, TX",
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                    },
                },
                "required": ["location"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What's the weather in Austin?"}],
    tools=tools,
    tool_choice="auto",
)

# Check if the model wants to call a function
message = response.choices[0].message
if message.tool_calls:
    call = message.tool_calls[0]
    args = json.loads(call.function.arguments)
    print(f"Model wants to call: {call.function.name}")
    print(f"With arguments: {args}")
    # You would then execute get_weather(args) and send the
    # result back to the model for a final response

Anthropic Messages API with the official SDK:

import anthropic

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

# Basic message
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="You are a helpful coding tutor.",
    messages=[
        {"role": "user", "content": "Explain decorators in Python."},
    ],
)

print(message.content[0].text)
print(f"Input tokens: {message.usage.input_tokens}")
print(f"Output tokens: {message.usage.output_tokens}")

Claude tool use:

import anthropic

client = anthropic.Anthropic()

# Define available tools
tools = [
    {
        "name": "get_stock_price",
        "description": "Get the current stock price for a ticker symbol",
        "input_schema": {
            "type": "object",
            "properties": {
                "ticker": {
                    "type": "string",
                    "description": "Stock ticker symbol, e.g. AAPL",
                },
            },
            "required": ["ticker"],
        },
    }
]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "What is Apple's stock price?"},
    ],
)

# Claude may respond with a tool_use content block
for block in response.content:
    if block.type == "tool_use":
        print(f"Tool: {block.name}")
        print(f"Input: {block.input}")  # {"ticker": "AAPL"}
        # Execute the tool and send results back to Claude
    elif block.type == "text":
        print(f"Text: {block.text}")

Hugging Face Inference API:

from huggingface_hub import InferenceClient

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

# Text generation with an open model
response = client.text_generation(
    "The future of AI is",
    model="meta-llama/Llama-3.3-70B-Instruct",
    max_new_tokens=200,
)
print(response)

# Sentiment analysis with a specialized model
result = client.text_classification(
    "I love this product! It works perfectly.",
    model="distilbert/distilbert-base-uncased-finetuned-sst-2-english",
)
print(result)  # [{"label": "POSITIVE", "score": 0.9998}]

# Image generation
image = client.text_to_image(
    "A serene mountain landscape at sunset, oil painting style",
    model="stabilityai/stable-diffusion-xl-base-1.0",
)
image.save("landscape.png")

A complete AI-powered research assistant:

import anthropic
import json

client = anthropic.Anthropic()

def research_topic(topic: str) -> dict:
    """Generate a structured research summary on any topic."""

    # Step 1: Generate a detailed research summary
    summary_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        system=(
            "You are a research assistant. Provide accurate, "
            "well-organized summaries with specific facts and "
            "data points when available."
        ),
        messages=[
            {
                "role": "user",
                "content": f"Write a comprehensive research summary "
                           f"about: {topic}",
            },
        ],
    )
    summary = summary_response.content[0].text

    # Step 2: Extract structured data from the summary
    extraction_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"""Extract key information from this research
summary and return it as JSON with these keys:
- "title": a concise title
- "key_points": array of 3-5 main findings
- "applications": array of practical applications
- "challenges": array of current challenges or limitations
- "confidence": "high", "medium", or "low" based on how
  well-established the information is

Summary:
{summary}

Return only valid JSON, no other text.""",
            },
        ],
    )

    structured = json.loads(extraction_response.content[0].text)
    structured["full_summary"] = summary

    return structured


# Usage
if __name__ == "__main__":
    result = research_topic("quantum computing applications in 2026")

    print(f"Title: {result['title']}")
    print(f"Confidence: {result['confidence']}")
    print("\nKey Points:")
    for point in result["key_points"]:
        print(f"  - {point}")
    print("\nApplications:")
    for app in result["applications"]:
        print(f"  - {app}")
    print("\nChallenges:")
    for challenge in result["challenges"]:
        print(f"  - {challenge}")

Robust API error handling:

import anthropic
import time

client = anthropic.Anthropic()

def safe_api_call(
    messages,
    model = "claude-sonnet-4-20250514",
    max_retries = 3,
):
    """Make a resilient API call with retry logic."""
    for attempt in range(max_retries):
        try:
            response = client.messages.create(
                model=model,
                max_tokens=1024,
                messages=messages,
            )
            return response.content[0].text

        except anthropic.RateLimitError:
            wait = 2 ** attempt
            print(f"Rate limited. Retrying in {wait}s...")
            time.sleep(wait)

        except anthropic.APIConnectionError:
            wait = 2 ** attempt
            print(f"Connection error. Retrying in {wait}s...")
            time.sleep(wait)

        except anthropic.BadRequestError as e:
            # Don't retry client errors — fix the request
            print(f"Bad request: {e}")
            raise

        except anthropic.APIStatusError as e:
            if e.status_code >= 500:
                wait = 2 ** attempt
                print(f"Server error. Retrying in {wait}s...")
                time.sleep(wait)
            else:
                raise

    raise Exception(f"Failed after {max_retries} retries")