Claude 4 Opus API Complete Guide 2026

Overview

Claude 4 Opus by Anthropic is a leading AI model in 2026, renowned for its excellence in long-form writing, analysis, and safety. This guide covers everything from API setup to production deployment.

Model Highlights

AttributeDetails

ModelClaude 4 Opus ProviderAnthropic Strengthslong-form writing, analysis, and safety Pricing$15/1M tokens Best ForProduction applications, enterprise use

Quick Start

Installation

bash
Install the official SDK
pip install anthropic
Or use the OpenAI-compatible interface
pip install openai

Environment Setup

bash
.env
API_KEY=your_anthropic_key_here

Your First API Call

python
import os
from openai import OpenAI  # Many providers support OpenAI compatibility
client = OpenAI(
    api_key=os.environ["API_KEY"],
    base_url="https://api.anthropic.com/v1"
)
response = client.chat.completions.create(
    model="claude-4-opus",
    messages=[
        {"role": "system", "content": "You are a helpful AI assistant."},
        {"role": "user", "content": "Explain the main advantages of your model"}
    ],
    max_tokens=1024,
    temperature=0.7
)
print(response.choices[0].message.content)
print(f"Tokens used: {response.usage.total_tokens}")

Core Features

Streaming Responses

python
async def stream_response(prompt: str):
    """Stream tokens for better user experience."""
    stream = client.chat.completions.create(
        model="claude-4-opus",
        messages=[{"role": "user", "content": prompt}],
        stream=True,
        max_tokens=2048
    )
    
    full_response = ""
    for chunk in stream:
        if chunk.choices[0].delta.content:
            content = chunk.choices[0].delta.content
            print(content, end="", flush=True)
            full_response += content
    
    return full_response
Usage
import asyncio
result = asyncio.run(stream_response("Write a technical analysis of long-form writing, analysis, and safety"))

Function Calling / Tool Use

python
import json
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_data",
            "description": "Retrieve data from external source",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"},
                    "limit": {"type": "integer", "description": "Max results", "default": 10}
                },
                "required": ["query"]
            }
        }
    }
]
response = client.chat.completions.create(
    model="claude-4-opus",
    messages=[{"role": "user", "content": "Find information about long-form writing, analysis, and safety"}],
    tools=tools,
    tool_choice="auto"
)
Handle tool calls
if response.choices[0].finish_reason == "tool_calls":
    tool_call = response.choices[0].message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    print(f"Tool called: {tool_call.function.name}")
    print(f"Arguments: {args}")

Structured Output (JSON Mode)

python
from pydantic import BaseModel
class AnalysisResult(BaseModel):
    summary: str
    key_points: list[str]
    confidence: float
    recommendations: list[str]
def analyze_with_structure(text: str) -> AnalysisResult:
    """Get structured JSON output from the model."""
    response = client.chat.completions.create(
        model="claude-4-opus",
        messages=[
            {"role": "system", "content": "Return analysis as JSON matching the schema."},
            {"role": "user", "content": f"Analyze: {text}"}
        ],
        response_format={"type": "json_object"},
        temperature=0.1
    )
    
    data = json.loads(response.choices[0].message.content)
    return AnalysisResult(**data)

Building a Production Application

FastAPI Integration

python
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import asyncio
app = FastAPI(title="Claude 4 Opus API Service")
class ChatRequest(BaseModel):
    message: str
    system_prompt: str = "You are a helpful assistant."
    stream: bool = False
@app.post("/chat")
async def chat_endpoint(request: ChatRequest):
    if request.stream:
        async def generate():
            stream = client.chat.completions.create(
                model="claude-4-opus",
                messages=[
                    {"role": "system", "content": request.system_prompt},
                    {"role": "user", "content": request.message}
                ],
                stream=True
            )
            for chunk in stream:
                if chunk.choices[0].delta.content:
                    yield chunk.choices[0].delta.content
        
        return StreamingResponse(generate(), media_type="text/plain")
    
    response = client.chat.completions.create(
        model="claude-4-opus",
        messages=[
            {"role": "system", "content": request.system_prompt},
            {"role": "user", "content": request.message}
        ]
    )
    
    return {"response": response.choices[0].message.content}

Cost Optimization

python
Monitor and optimize API costs
class CostTracker:
    def __init__(self):
        self.total_tokens = 0
        self.total_cost = 0.0
    
    def track(self, usage, input_price_per_1m: float, output_price_per_1m: float):
        input_cost = (usage.prompt_tokens / 1_000_000) * input_price_per_1m
        output_cost = (usage.completion_tokens / 1_000_000) * output_price_per_1m
        
        self.total_tokens += usage.total_tokens
        self.total_cost += input_cost + output_cost
        
        return input_cost + output_cost
    
    def report(self):
        print(f"Total tokens: {self.total_tokens:,}")
        print(f"Total cost: ${self.total_cost:.4f}")
tracker = CostTracker()
In your API calls:
response = client.chat.completions.create(...)
cost = tracker.track(response.usage, input_price_per_1m=1.5, output_price_per_1m=5.0)
print(f"This request cost: ${cost:.4f}")

Performance Benchmarks

Claude 4 Opus consistently performs well on industry benchmarks:

BenchmarkScorePercentile

MMLU85-92%Top tier HumanEval78-92%Excellent MATH65-85%Strong GPQA55-72%Advanced

Pricing Guide

Claude 4 Opus pricing: $15/1M tokens (input tokens)

Tips to reduce costs:

Use smaller models for simple tasks

Enable prompt caching for repeated system prompts

Use batch API for non-real-time processing (usually 50% discount)

Optimize prompt length without sacrificing quality

Conclusion

Claude 4 Opus by Anthropic excels at long-form writing, analysis, and safety. Whether you're building a simple chatbot or a complex enterprise AI system, this guide gives you the foundation to ship production-quality applications.

---

*Updated for Claude 4 Opus latest API version | May 2026*