Cara Menggunakan API Claude Opus 4.7

TL;DR

Claude Opus 4.7 (claude-opus-4-7) adalah model GA paling mumpuni dari Anthropic. Ini mendukung jendela konteks 1 juta token, output maks 128K, pemikiran adaptif, tingkat upaya xhigh baru, anggaran tugas, visi resolusi tinggi (3,75 MP), dan penggunaan alat. Panduan ini mencakup penyiapan API, autentikasi, dan contoh kode yang berfungsi dalam Python, TypeScript, dan cURL untuk setiap kemampuan utama.

Pendahuluan

Anthropic merilis Claude Opus 4.7 pada 16 April 2026. Ini adalah model paling kuat dalam keluarga Claude dan pilihan utama untuk penalaran kompleks, agen otonom, dan alur kerja yang banyak menggunakan visi.

Jika Anda pernah menggunakan API Claude sebelumnya, sebagian besar antarmukanya sudah familiar. Namun Opus 4.7 memperkenalkan beberapa kemampuan baru dan perubahan yang merusak yang memerlukan pembaruan kode. Anggaran pemikiran yang diperpanjang sudah tidak ada lagi. Parameter sampling (temperature, top_p, top_k) juga sudah tidak ada. Mode berpikir sekarang hanya mendukung pemikiran adaptif, dan secara default nonaktif.

Panduan ini akan memandu Anda melalui setiap langkah: mendapatkan kunci API Anda, membuat permintaan pertama Anda, menggunakan pemikiran adaptif, mengirim gambar resolusi tinggi, menyiapkan penggunaan alat, mengonfigurasi anggaran tugas, dan streaming respons. Setiap contoh telah diuji dan siap untuk disalin. Anda juga akan melihat cara melakukan debug dan menguji panggilan API Anda dengan Apidog, yang membuat pemeriksaan percakapan penggunaan alat multi-giliran jauh lebih mudah daripada mengurai JSON mentah.

Memulai

Dapatkan Kunci API Anda

1. Daftar di console.anthropic.com
2. Navigasikan ke API Keys di dasbor
3. Klik Create Key dan salin kuncinya
4. Simpan sebagai variabel lingkungan:

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 dikirim ke:

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

Header yang diperlukan:

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

Permintaan Teks Dasar

Panggilan API paling sederhana. Kirim pesan, dapatkan 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

Pemikiran adaptif adalah satu-satunya mode pemikiran yang didukung di Opus 4.7. Ini memungkinkan Claude mengalokasikan token penalaran secara dinamis berdasarkan kompleksitas tugas. Secara default tidak aktif — Anda harus mengaktifkannya secara eksplisit.

Python:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={
        "type": "adaptive",
        "display": "summarized"  # optional: see thinking output
    },
    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-poin penting:

• "type": "adaptive" mengaktifkan pemikiran. Jangan atur budget_tokens — itu akan mengembalikan kesalahan 400 sekarang
• "display": "summarized" membuat konten pemikiran terlihat di respons. Defaultnya adalah "omitted"
• Gabungkan dengan parameter effort untuk mengontrol kedalaman penalaran

Menggunakan Parameter Usaha (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 upaya untuk Opus 4.7:

Visi Resolusi Tinggi

Opus 4.7 menerima gambar hingga 2.576 piksel pada sisi panjang (3,75 megapiksel). Koordinat dipetakan 1:1 ke piksel aktual.

Python — menganalisis 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 — menganalisis gambar lokal dengan 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?"
                }
            ]
        }
    ]
)

Gambar resolusi lebih tinggi mengonsumsi lebih banyak token. Jika Anda tidak memerlukan fidelitas penuh, ubah ukuran gambar sebelum mengirim untuk mengurangi biaya.

Penggunaan Alat (Panggilan Fungsi)

Penggunaan alat memungkinkan Claude memanggil fungsi yang Anda definisikan. Opus 4.7 cenderung menggunakan lebih sedikit panggilan alat secara default, lebih memilih penalaran. Tingkatkan tingkat upaya untuk meningkatkan penggunaan alat.

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?"}
]

# First call — Claude requests a tool
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

# Process tool calls
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":
            # Execute your function here
            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})

    # Second call — Claude uses the tool result
    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 agen otonom yang menjalankan beberapa panggilan alat 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)

Anggaran tugas memberi Claude alokasi token untuk seluruh lingkaran agensi. Model melihat hitungan mundur yang berjalan dan menyelesaikan pekerjaan saat anggaran dikonsumsi.

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 utama:

• Anggaran minimum: 20.000 token
• Bersifat saran, bukan batas keras — Claude mungkin melebihi batas
• Berbeda dari max_tokens (batas keras yang tidak dapat dilihat model)
• Membutuhkan header beta task-budgets-2026-03-13

Streaming Respons

Streaming respons untuk output real-time di antarmuka obrolan.

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 Anda mengaktifkan pemikiran adaptif dengan display: "summarized", blok pemikiran akan mengalir terlebih dahulu, diikuti oleh respons teks. Tanpa display: "summarized", pengguna akan melihat jeda selama pemikiran diikuti oleh output teks.

Caching Prompt

Kurangi biaya untuk konteks berulang (prompt sistem, dokumen panjang) dengan menyimpannya dalam cache.

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 untuk Opus 4.7:

Satu kali pembacaan cache membayar penulisan cache 5 menit. Dua kali pembacaan membayar penulisan 1 jam.

Percakapan Multi-Giliran

Pertahankan konteks di seluruh giliran dengan menambahkan ke array pesan.

messages = []

# Turn 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})

# Turn 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

Membangun integrasi API Claude melibatkan payload yang kompleks: pesan multi-giliran, definisi alat, hasil alat, gambar base64, dan respons streaming. Alat seperti Apidog menyederhanakan debugging dan pengujian.

Siapkan lingkungan Anda:

1. Buat proyek baru di Apidog dan tambahkan endpoint API Pesan Claude
2. Simpan ANTHROPIC_API_KEY Anda dalam variabel lingkungan
3. Atur header yang diperlukan (x-api-key, anthropic-version, content-type)

Uji alur penggunaan alat:

Apidog memungkinkan Anda merangkai permintaan, sehingga Anda dapat mensimulasikan lingkaran penggunaan alat yang lengkap: kirim pesan awal, periksa panggilan alat Claude, bangun hasil alat, dan kirim kembali. Inspektur permintaan/respons visual menunjukkan dengan tepat apa yang ada di setiap payload.

Bandingkan model:

Jalankan prompt yang sama terhadap claude-opus-4-6 dan claude-opus-4-7 untuk membandingkan jumlah token, kualitas respons, dan latensi. Runner pengujian Apidog membuat perbandingan A/B dapat diulang.

Validasi skema:

Definisikan skema JSON untuk format respons yang Anda harapkan dan biarkan Apidog secara otomatis memvalidasi bahwa respons Claude cocok. Ini menangkap regresi ketika Anda mengubah prompt atau beralih model.

Kesalahan Umum dan Perbaikan

Referensi Harga

Catatan: Tokenizer baru Opus 4.7 mungkin menggunakan hingga 35% lebih banyak token untuk teks yang sama dibandingkan dengan Opus 4.6. Gunakan endpoint /v1/messages/count_tokens untuk memperkirakan biaya sebelum deployment produksi.

Kesimpulan

Claude Opus 4.7 adalah model paling mumpuni dalam keluarga Claude. API ini sebagian besar kompatibel dengan Opus 4.6, tetapi penghapusan anggaran pemikiran yang diperpanjang dan parameter sampling memerlukan perubahan kode. Kemampuan baru — pemikiran adaptif, upaya xhigh, anggaran tugas, dan visi resolusi tinggi — memberi Anda lebih banyak kendali atas bagaimana model bernalar dan berapa biayanya.

Mulai dengan permintaan teks dasar, tambahkan pemikiran adaptif untuk tugas-tugas kompleks, dan lapisi dengan penggunaan alat dan anggaran tugas seiring pertumbuhan agen Anda. Gunakan Apidog untuk menguji integrasi Anda, memvalidasi payload, dan membandingkan kinerja di seluruh versi model.