Cara Menggunakan API Claude Opus 4.7

TL;DR

Claude Opus 4.7 (claude-opus-4-7) adalah model GA terbaru dari Anthropic yang mendukung jendela konteks 1 juta token, output hingga 128K, pemikiran adaptif, tingkat upaya xhigh baru, anggaran tugas, visi resolusi tinggi (3,75 MP), dan penggunaan alat. Panduan ini menyajikan penyiapan API, autentikasi, serta contoh kode siap pakai dalam Python, TypeScript, dan cURL untuk semua fitur utama.

Coba Apidog hari ini

Pendahuluan

Anthropic merilis Claude Opus 4.7 pada 16 April 2026. Ini adalah model paling powerful di keluarga Claude, ideal untuk penalaran kompleks, agen otonom, hingga workflow berbasis visi.

Jika sudah familiar dengan API Claude, sebagian besar interface-nya masih sama. Namun, Opus 4.7 membawa fitur baru dan breaking changes: anggaran pemikiran diperpanjang dihapus, parameter sampling (temperature, top_p, top_k) tidak lagi tersedia, dan mode pemikiran kini hanya mendukung “adaptive thinking” yang secara default tidak aktif.

Panduan ini akan membimbing Anda langkah demi langkah: dari mendapatkan API key, melakukan request pertama, mengaktifkan pemikiran adaptif, upload gambar resolusi tinggi, setup tools, konfigurasi task budget, hingga streaming response. Semua contoh bisa langsung disalin. Anda juga akan belajar cara debugging dan testing API call dengan Apidog, yang memudahkan inspeksi payload multi-giliran penggunaan alat.

Memulai

Dapatkan Kunci API Anda

1. Daftar di console.anthropic.com
2. Buka menu API Keys di dashboard
3. Klik Create Key lalu salin kunci Anda
4. Simpan sebagai environment variable:

export ANTHROPIC_API_KEY="sk-ant-your-key-here"

Instal SDK

Python:

pip install anthropic

TypeScript/Node.js:

npm install @anthropic-ai/sdk

Endpoint API

Semua permintaan menggunakan endpoint:

POST https://api.anthropic.com/v1/messages

Header wajib:

x-api-key: YOUR_API_KEY
anthropic-version: 2023-06-01
content-type: application/json

Permintaan Teks Dasar

Panggilan API sederhana: kirim pesan, terima respons.

Python:

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain how HTTP/2 server push works in three sentences."}
    ]
)

print(message.content[0].text)

TypeScript:

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

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Explain how HTTP/2 server push works in three sentences." }
  ],
});

console.log(message.content[0].text);

cURL:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Explain how HTTP/2 server push works in three sentences."}
    ]
  }'

Pemikiran Adaptif

Adaptive thinking adalah satu-satunya mode thinking di Opus 4.7. Anda harus mengaktifkannya secara eksplisit untuk mengalokasikan token reasoning berdasarkan kompleksitas tugas.

Python:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={
        "type": "adaptive",
        "display": "summarized"  # opsional: lihat output pemikiran
    },
    messages=[
        {"role": "user", "content": "Analyze this algorithm's time complexity and suggest optimizations:\n\ndef find_pairs(arr, target):\n    result = []\n    for i in range(len(arr)):\n        for j in range(i+1, len(arr)):\n            if arr[i] + arr[j] == target:\n                result.append((arr[i], arr[j]))\n    return result"}
    ]
)

for block in message.content:
    if block.type == "thinking":
        print("Thinking:", block.thinking)
    elif block.type == "text":
        print("Response:", block.text)

Poin penting:

• Gunakan "type": "adaptive" untuk mengaktifkan mode ini. Jangan set budget_tokens (akan error 400).
• "display": "summarized" membuat thought process Claude terlihat di response (default: "omitted").
• Kombinasikan dengan parameter effort untuk mengatur tingkat reasoning.

Menggunakan Parameter Effort

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},  # xhigh | high | medium | low
    messages=[
        {"role": "user", "content": "Review this pull request for security vulnerabilities..."}
    ]
)

Tingkat effort untuk Opus 4.7:

Tingkat	Cocok untuk
xhigh	Coding, agensi, reasoning kompleks
high	Tugas sensitif kecerdasan
medium	Keseimbangan kecepatan & kualitas
low	Tugas sederhana, respons cepat

Visi Resolusi Tinggi

Opus 4.7 menerima gambar hingga 2.576px (3,75MP). Koordinat langsung ke piksel asli.

Python — Analisis gambar dari URL:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://example.com/architecture-diagram.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Describe this architecture diagram. List every service and the connections between them."
                }
            ]
        }
    ]
)

print(message.content[0].text)

Python — Analisis gambar lokal (base64):

import base64

with open("screenshot.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "What UI bugs do you see in this screenshot?"
                }
            ]
        }
    ]
)

Gunakan gambar beresolusi lebih rendah jika tidak butuh detail penuh untuk menghemat token.

Penggunaan Alat (Function Calling)

Penggunaan alat memungkinkan Claude memanggil fungsi yang Anda definisikan. Opus 4.7 cenderung lebih selektif dalam tool calling, tingkatkan effort untuk memicu penggunaan alat lebih sering.

Python:

import json

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Returns temperature, conditions, and humidity.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name, e.g. 'San Francisco'"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit"
                }
            },
            "required": ["city"]
        }
    }
]

messages = [
    {"role": "user", "content": "What's the weather like in Tokyo right now?"}
]

# Call pertama — Claude meminta tool
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

# Proses tool call
if response.stop_reason == "tool_use":
    messages.append({"role": "assistant", "content": response.content})

    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            # Eksekusi fungsi Anda di sini
            result = {"temperature": 22, "conditions": "Partly cloudy", "humidity": 65}

            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result)
            })

    messages.append({"role": "user", "content": tool_results})

    # Call kedua — Claude memakai hasil tool
    final_response = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    print(final_response.content[0].text)

Pola Lingkaran Agensi

Untuk agent otonom yang menjalankan multi tool call secara berurutan:

def run_agent(system_prompt: str, tools: list, user_message: str) -> str:
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=16384,
            system=system_prompt,
            tools=tools,
            thinking={"type": "adaptive"},
            output_config={"effort": "xhigh"},
            messages=messages,
        )

        messages.append({"role": "assistant", "content": response.content})

        if response.stop_reason != "tool_use":
            return "".join(
                block.text for block in response.content
                if hasattr(block, "text")
            )

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })

        messages.append({"role": "user", "content": tool_results})

Anggaran Tugas (Beta)

Task budget memberikan Claude alokasi token untuk seluruh loop agensi. Model dapat “melihat” countdown token dan menyelesaikan tugas saat budget habis.

response = client.beta.messages.create(
    model="claude-opus-4-7",
    max_tokens=128000,
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[
        {"role": "user", "content": "Review the codebase and propose a refactor plan."}
    ],
    betas=["task-budgets-2026-03-13"],
)

Batasan:

• Minimal: 20.000 token
• Bersifat saran, bukan hard limit — Claude mungkin melebihi budget
• Berbeda dari max_tokens (hard limit, tidak dapat dilihat model)
• Perlu header beta task-budgets-2026-03-13

Streaming Respons

Gunakan streaming untuk output real-time (misal chat UI).

Python:

with client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Write a Python function to parse CSV files with error handling."}
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

TypeScript:

const stream = await client.messages.stream({
  model: "claude-opus-4-7",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Write a Python function to parse CSV files with error handling." }
  ],
});

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

Jika menggunakan pemikiran adaptif dengan display: "summarized", blok pemikiran akan di-stream lebih dulu, lalu respons teks. Jika tidak, akan ada jeda saat Claude berpikir sebelum teks keluar.

Caching Prompt

Kurangi biaya untuk konteks berulang (misal: prompt sistem, dokumen panjang) dengan cache prompt.

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are a senior code reviewer. Review code for security vulnerabilities, performance issues, and best practices violations...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": "Review this function:\n\ndef process_user_input(data):\n    return eval(data)"}
    ]
)

Harga cache Opus 4.7:

Operasi	Biaya
Write cache 5 menit	$6.25 / MTok (1.25x)
Write cache 1 jam	$10 / MTok (2x)
Read/hit cache	$0.50 / MTok (0.1x)

Satu kali cache read sudah menutupi cache write 5 menit. Dua kali read menutupi write 1 jam.

Percakapan Multi-Giliran

Pertahankan konteks percakapan dengan menambah array pesan.

messages = []

# Giliran 1
messages.append({"role": "user", "content": "I need to build a REST API for a todo app."})

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=messages,
)

messages.append({"role": "assistant", "content": response.content})

# Giliran 2
messages.append({"role": "user", "content": "Add authentication with JWT tokens."})

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=messages,
)

Menguji Panggilan API Anda dengan Apidog

Integrasi API Claude menghasilkan payload kompleks: pesan multi-giliran, definisi & hasil alat, gambar base64, dan respons streaming. Tool seperti Apidog menyederhanakan debugging dan testing.

Langkah Setup:

1. Buat project baru di Apidog dan tambahkan endpoint API Pesan Claude
2. Simpan ANTHROPIC_API_KEY sebagai environment variable
3. Pastikan header (x-api-key, anthropic-version, content-type) sudah benar

Cara Uji Alur Tool Use:

Apidog memungkinkan Anda merangkai permintaan sehingga bisa mensimulasikan loop penggunaan alat: kirim pesan awal, cek panggilan alat Claude, buat hasil alat, dan kirim ulang. Inspector visual memperjelas isi payload setiap tahap.

Bandingkan Model:

Jalankan prompt sama pada claude-opus-4-6 vs claude-opus-4-7 untuk membandingkan token usage, kualitas respons, dan latensi. Test runner Apidog memudahkan A/B testing berulang.

Validasi Skema:

Definisikan skema JSON untuk format respons yang diharapkan, lalu biarkan Apidog otomatis memvalidasi kecocokan respons Claude. Ini menangkap regresi ketika prompt atau model berubah.

Kesalahan Umum dan Solusinya

Kesalahan	Penyebab	Solusi
400: thinking.budget_tokens tidak didukung	Menggunakan sintaks pemikiran lama	Pakai thinking: {"type": "adaptive"}
400: temperature tidak didukung	Set parameter sampling non-default	Hapus temperature, top_p, top_k
400: max_tokens terlampaui	Tokenizer baru lebih verbose	Naikkan max_tokens (hingga 128.000)
429: Rate limited	Permintaan terlalu banyak	Terapkan exponential backoff, cek tier limit
Blok pemikiran kosong	Default thinking display "omitted"	Tambahkan display: "summarized" di thinking

Referensi Harga

Penggunaan	Biaya
Token masukan	$5 / MTok
Token keluaran	$25 / MTok
Masukan batch	$2.50 / MTok
Keluaran batch	$12.50 / MTok
Pembacaan cache	$0.50 / MTok
Penulisan cache 5 menit	$6.25 / MTok
Penulisan cache 1 jam	$10 / MTok

Tokenizer Opus 4.7 kadang memakai hingga 35% lebih banyak token dibanding Opus 4.6. Gunakan endpoint /v1/messages/count_tokens untuk estimasi biaya sebelum produksi.

Kesimpulan

Claude Opus 4.7 adalah model Claude terkuat. API-nya sebagian besar kompatibel dengan Opus 4.6, namun beberapa breaking change (penghapusan extended thinking budget & parameter sampling) mengharuskan update kode. Fitur baru — adaptive thinking, effort xhigh, task budget, visi resolusi tinggi — memberi kendali lebih atas reasoning dan biaya.

Mulai dari permintaan teks dasar, aktifkan pemikiran adaptif untuk tugas kompleks, lalu layer dengan tool use & task budget saat agent berkembang. Uji integrasi dan validasi payload Anda dengan Apidog untuk membandingkan performa antar versi model.