วิธีใช้ Claude Opus 5 API

Claude Opus 5 เปิดตัวเมื่อวันที่ 24 กรกฎาคม 2026 และ Anthropic ตอนนี้แนะนำให้นักพัฒนาเริ่มต้นใช้งานเป็นอันดับแรก: เอกสารระบุว่าหากคุณไม่แน่ใจว่าจะใช้โมเดลใด ให้เริ่มต้นด้วย Claude Opus 5 ID โมเดล API คือสตริง claude-opus-5 แบบตรงตัว โดยไม่มีส่วนต่อท้ายวันที่

คู่มือนี้จะนำคุณไปตลอดเส้นทาง: การขอคีย์, การส่งคำขอแรก, การสตรีม, การใช้เครื่องมือ, การคิดแบบปรับตัว, พารามิเตอร์ effort และการอ่านอ็อบเจกต์ usage เพื่อยืนยันว่าแคชพรอมต์ของคุณทำงานอยู่ ทุกคำขอในที่นี้เป็น HTTP ธรรมดาที่มี JSON เป็นอินพุตและ JSON เป็นเอาต์พุต ดังนั้นคุณจึงสามารถสร้างและดีบักได้ใน Apidog ก่อนที่คุณจะนำไปใช้ในโค้ดแอปพลิเคชัน

button

การเปลี่ยนแปลงสองอย่างจาก Opus 4.8 จะส่งผลกระทบตั้งแต่การเรียกใช้ครั้งแรกสุด ดังนั้นจึงควรกล่าวถึงก่อนสิ่งอื่นใด หากคุณกำลังย้ายบริการที่มีอยู่เดิมแทนที่จะเริ่มต้นใหม่ ให้อ่าน คู่มือการย้ายจาก Opus 4.8 ไป Opus 5 ฉบับเต็ม ไปพร้อมกับฉบับนี้

ก่อนการเรียกใช้ครั้งแรก: การเปลี่ยนแปลงที่สำคัญสองประการ

1. การคิด (Thinking) เปิดใช้งานโดยค่าเริ่มต้น ใน Opus 4.8 คำขอที่ไม่มีฟิลด์ thinking จะทำงานโดยไม่มีการคิดเลย ใน Opus 5 คำขอเดียวกันนั้นจะทำงานพร้อมกับการคิดแบบปรับตัว (adaptive thinking) max_tokens ยังคงเป็นขีดจำกัดสูงสุดสำหรับโทเค็นการคิดและโทเค็นการตอบสนองรวมกัน ดังนั้นเนื้อหาคำขอที่คุณคัดลอกมาจากการทำงานร่วมกับ 4.8 อาจถูกตัดกลางคันได้ หาก max_tokens ของคุณถูกปรับแต่งอย่างแม่นยำตามความยาวของเอาต์พุตที่คาดไว้ ให้เพิ่มค่านี้ขึ้น

2. การปิดใช้งานการคิดจะจำกัดระดับความพยายามของคุณ การส่ง thinking: {"type": "disabled"} พร้อมกับค่า effort เป็น xhigh หรือ max จะส่งคืนข้อผิดพลาด 400 Anthropic บังคับใช้สิ่งนี้ต่อคำขอ ดังนั้นจึงล้มเหลวทันทีแทนที่จะลดประสิทธิภาพลงอย่างเงียบๆ วิธีแก้ไขคือเลือกอย่างใดอย่างหนึ่ง: เปิดใช้งานการคิดและลด effort เพื่อควบคุมค่าใช้จ่าย หรือปิดใช้งานการคิดและจำกัด effort ไว้ที่ high

คำแนะนำของ Anthropic เองคือตัวเลือกแรก เมื่อปิดใช้งานการคิด บางครั้ง Opus 5 จะเขียนการเรียกใช้เครื่องมือออกมาเป็นข้อความธรรมดา (ซึ่งไม่เคยถูกดำเนินการ และข้อความที่รั่วไหลจะปนเปื้อนในการวนซ้ำของเอเจนต์ในภายหลัง) และบางครั้งก็มีการรั่วไหลของแท็ก <thinking> ไปยังเอาต์พุตที่มองเห็นได้ การเปิดใช้งานการคิดและปรับลด effort จะช่วยหลีกเลี่ยงทั้งสองอย่างนี้

การเปลี่ยนแปลงทั้งสองมีการบันทึกไว้ใน คู่มือการย้ายโมเดล ของ Anthropic

ขั้นตอนที่ 1: ขอ API key

ลงชื่อเข้าใช้ Claude Developer Platform, เปิดส่วน API keys ในการตั้งค่าองค์กรของคุณ, และสร้างคีย์ คัดลอกเพียงครั้งเดียว; คุณจะไม่สามารถอ่านกลับมาได้ในภายหลัง

เก็บไว้ในตัวแปรสภาพแวดล้อมแทนที่จะวางลงในโค้ด:

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

หากคุณกำลังทดสอบในไคลเอนต์ GUI ให้ใส่คีย์ในตัวแปรสภาพแวดล้อมที่นั่นด้วย ใน Apidog นั่นหมายถึงการสร้างสภาพแวดล้อม (Local, Staging, Production) ที่มีตัวแปร ANTHROPIC_API_KEY จากนั้นอ้างอิง {{ANTHROPIC_API_KEY}} ในส่วนหัว คำขอที่คุณบันทึกไว้ยังคงสามารถแชร์กับทีมได้ และความลับจะไม่ถูกบันทึกในการส่งออกคอลเลกชัน

คุณยังต้องเพิ่มเครดิตการเรียกเก็บเงินก่อนที่คำขอจะสำเร็จ อัตราสำหรับ Opus 5 คือ 5 ดอลลาร์ต่อล้านโทเค็นอินพุต และ 25 ดอลลาร์ต่อล้านโทเค็นเอาต์พุต ซึ่งเท่ากับ Opus 4.8 และ รายละเอียดราคาฉบับเต็ม ครอบคลุมอัตราการแคช, แบตช์, และโหมดเร็ว

ขั้นตอนที่ 2: ส่งคำขอแรกของคุณ

Endpoint คือ POST https://api.anthropic.com/v1/messages ส่วนหัวสามรายการที่สำคัญ: คีย์ของคุณ, เวอร์ชัน API, และประเภทเนื้อหา

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "messages": [
      {"role": "user", "content": "Explain the difference between a 429 and a 529 from an API perspective."}
    ]
  }'

โปรดสังเกตค่า max_tokens 4096 เป็นการเพิ่มขึ้นอย่างจงใจจาก 1024 ที่คุณเห็นในตัวอย่างเริ่มต้นส่วนใหญ่ เนื่องจากโทเค็นการคิดตอนนี้มาจากงบประมาณเดียวกัน

โค้ด Python ที่เทียบเท่าผ่าน SDK อย่างเป็นทางการ:

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

message = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Explain the difference between a 429 and a 529 from an API perspective."}
    ],
)

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

การวนซ้ำเหนือ message.content นั้นไม่ใช่แค่การตกแต่ง content ของการตอบสนองเป็นอาร์เรย์ของบล็อกที่มีประเภท และเมื่อเปิดการคิด คุณจะเห็นบล็อก thinking ก่อนบล็อก text โค้ดที่สันนิษฐานว่า content[0].text เป็นคำตอบจะหยุดทำงานบน Opus 5 นี่คือความล้มเหลวในการอัปเกรดที่พบบ่อยที่สุด และเป็นเรื่องง่ายที่จะมองข้ามเพราะคำขอยังคงส่งคืน 200

ข้อกำหนดบางประการที่คุณควรทราบขณะสร้าง: Opus 5 มี context window ขนาด 1M โทเค็นทั้งแบบเริ่มต้นและสูงสุด (ไม่มี beta header, ไม่มีพรีเมียมราคาสำหรับ long-context), เอาต์พุตสูงสุด 128k บน Messages API และขีดจำกัดความรู้ถึงเดือนพฤษภาคม 2026 ภาพรวมโมเดล มีตารางฉบับเต็ม และ คำอธิบาย Opus 5 ของเราครอบคลุมข้อมูลจำเพาะที่เหลือ

ขั้นตอนที่ 3: ทำงานกับการคิดแบบปรับตัว

การคิดแบบปรับตัวหมายถึงโมเดลตัดสินใจว่าจะใช้เหตุผลภายในมากน้อยเพียงใดสำหรับคำขอหนึ่งๆ คุณไม่ได้กำหนดงบประมาณโทเค็น คุณชี้นำมันด้วย effort ซึ่งจะกล่าวถึงในขั้นตอนถัดไป

สิ่งที่คุณต้องจัดการในโค้ด:

แยกวิเคราะห์บล็อกตามประเภท กรอง block.type == "text" สำหรับคำตอบที่มองเห็นได้ และ block.type == "thinking" หากคุณต้องการบันทึกการให้เหตุผล
ส่งบล็อกการคิดกลับไปโดยไม่เปลี่ยนแปลง ในการวนซ้ำแบบหลายรอบและการใช้เครื่องมือ ให้ผนวกอาร์เรย์เนื้อหาทั้งหมดของผู้ช่วยเข้ากับประวัติข้อความของคุณ แทนที่จะสร้างใหม่จากข้อความ การลบบล็อกออกกลางการสนทนาจะทำให้การวนซ้ำลดประสิทธิภาพลง
จัดงบประมาณ max_tokens สำหรับทั้งสองอย่าง การคิดรวมกับการตอบสนองจะใช้ขีดจำกัดเดียวกัน การถูกตัดจะแสดงเป็น stop_reason: "max_tokens" ดังนั้นให้ยืนยันฟิลด์นั้นในการทดสอบของคุณ

หากต้องการปิดการคิดโดยสมบูรณ์:

{
  "model": "claude-opus-5",
  "max_tokens": 4096,
  "thinking": {"type": "disabled"},
  "output_config": {"effort": "high"},
  "messages": [{"role": "user", "content": "Return only the HTTP status code."}]
}

ค่า Effort ถูกจำกัดไว้ที่ high ในคำขอข้างต้นโดยตั้งใจ หากคุณเพิ่มเป็น xhigh คุณจะได้รับข้อผิดพลาด 400 ที่อธิบายไว้ข้างต้น

ขั้นตอนที่ 4: ควบคุมค่าใช้จ่ายด้วย output_config.effort

ฟิลด์ effort อยู่ภายใต้ output_config และสามารถใช้ค่า low, medium, high, xhigh หรือ max ค่าเริ่มต้นคือ high นี่คือพารามิเตอร์ที่ข่าวทั่วไปอธิบายว่าเป็นการสลับระหว่างค่าใช้จ่ายและความสามารถ ใน API มันเป็นเพียงสตริงหนึ่งในเนื้อหาคำขอของคุณ

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-5",
    "max_tokens": 65536,
    "output_config": {"effort": "xhigh"},
    "messages": [
      {"role": "user", "content": "Refactor this handler to stream responses and keep backpressure."}
    ]
  }'

สามสิ่งที่คุณควรรู้ก่อนที่จะปรับแต่ง

ระดับต่างๆ ได้รับการปรับเทียบใหม่ Anthropic ระบุไว้อย่างชัดเจนว่าอย่าใช้การตั้งค่า effort ของ Opus 4.8 ข้ามมา low และ medium มีความสามารถที่แข็งแกร่งขึ้นอย่างมีนัยสำคัญใน Opus 5 เมื่อเทียบกับโมเดล Opus รุ่นก่อนหน้า ซึ่งหมายความว่าเวิร์กโหลดที่คุณเคยรันที่ high อาจทำงานได้ดีขึ้นด้วยราคาที่ถูกลง ตรวจสอบใหม่กับข้อมูลประเมินของคุณเองแทนที่จะเชื่อถือการแมป

xhigh ยังคงเป็นจุดเริ่มต้นที่แนะนำสำหรับการเขียนโค้ดและงานแบบ agentic และเป็นจุดที่ max_tokens มีความสำคัญที่สุด ให้พื้นที่กับมัน; 64k เป็นขีดจำกัดเริ่มต้นที่เหมาะสมสำหรับการวนซ้ำแบบ agentic ที่ยาวนาน ซึ่งเป็นเหตุผลที่โค้ดตัวอย่างข้างต้นใช้ 65536

Effort ที่ต่ำกว่าจะลดการคิด ไม่ใช่ความยาวที่มองเห็นได้ การตอบสนองเริ่มต้นและผลงานที่เขียนโดย Opus 5 มีความยาวมากกว่า Opus 4.8 หากคุณต้องการเอาต์พุตที่สั้นลง ให้ระบุในพรอมต์ การลดเหลือ low จะไม่ช่วยคุณได้ การเจาะลึกพารามิเตอร์ effort จะอธิบายระเบียบวิธีแบบเต็ม

ขั้นตอนที่ 5: สตรีมการตอบสนอง

เพิ่ม "stream": true แล้ว endpoint จะส่งคืน server-sent events แทนที่จะเป็น JSON body เดียว

with client.messages.stream(
    model="claude-opus-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Draft a retry policy for a flaky upstream."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    final = stream.get_final_message()
    print("\n\nusage:", final.usage)

ลำดับ SSE ดิบคือ message_start จากนั้น content_block_start / content_block_delta / content_block_stop ต่อบล็อก จากนั้น message_delta ที่มี stop_reason และจำนวนโทเค็นเอาต์พุตสุดท้าย จากนั้น message_stop

เมื่อเปิดการคิด คุณจะได้รับบล็อกเนื้อหาสองบล็อกที่สตรีมตามลำดับ: บล็อกการคิดที่เดลต้ามาถึงในรูปแบบ thinking_delta จากนั้นเป็นบล็อกข้อความที่มี text_delta UI ที่แสดงผลทุกเดลต้าลงในบัฟเฟอร์เดียวกันจะพิมพ์การให้เหตุผลของโมเดลให้ผู้ใช้ของคุณเห็น แยกเส้นทางเหล่านี้ตั้งแต่เริ่มต้น

การสตรีมยังเป็นส่วนที่ไคลเอนต์ GUI แสดงคุณค่าของมัน เพราะการอ่าน SSE ดิบในเทอร์มินัลเป็นเรื่องที่ยุ่งยาก Apidog แสดงผลกระแสเหตุการณ์เมื่อมาถึง ดังนั้นคุณจึงสามารถดูขอบเขตบล็อกและยืนยันสมมติฐานการแยกวิเคราะห์ของคุณก่อนที่จะเขียนโค้ด handler แม้แต่บรรทัดเดียว

ขั้นตอนที่ 6: เพิ่มการใช้เครื่องมือ

คำจำกัดความของเครื่องมืออยู่ในอาร์เรย์ tools โมเดลจะตอบกลับด้วย stop_reason: "tool_use" และบล็อกเนื้อหา tool_use; คุณจะดำเนินการเครื่องมือและส่งผลลัพธ์กลับไปเป็นบล็อก tool_result ในข้อความผู้ใช้ใหม่

tools = [
    {
        "name": "get_order_status",
        "description": "Look up the current status of a customer order by ID.",
        "input_schema": {
            "type": "object",
            "properties": {
                "order_id": {"type": "string", "description": "The order ID, e.g. A-10293"}
            },
            "required": ["order_id"],
        },
    }
]

message = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    tools=tools,
    messages=[{"role": "user", "content": "What's the status of order A-10293?"}],
)

if message.stop_reason == "tool_use":
    call = next(b for b in message.content if b.type == "tool_use")
    result = get_order_status(**call.input)

    follow_up = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        tools=tools,
        messages=[
            {"role": "user", "content": "What's the status of order A-10293?"},
            {"role": "assistant", "content": message.content},
            {"role": "user", "content": [
                {"type": "tool_result", "tool_use_id": call.id, "content": result}
            ]},
        ],
    )

การส่ง message.content ผ่านโดยตรงในรอบของ assistant จะรักษากล่องความคิด (thinking block) ไว้ อย่าสร้างรอบนั้นขึ้นมาเองด้วยมือ

รายละเอียดของ Opus 5 สองอย่างที่สำคัญสำหรับเอเจนต์: Overhead ของ system prompt สำหรับการใช้เครื่องมือนั้นต่ำกว่าใน Opus 4.8: 286 โทเค็นเมื่อตั้งค่า tool_choice เป็น auto หรือ none เทียบกับ 290 โทเค็นใน 4.8 และ 675 โทเค็นใน Opus 4.7 ค่าเล็กน้อยต่อคำขอ แต่มีนัยสำคัญเมื่อใช้ในเอเจนต์เป็นล้านๆ รอบ และยังมี beta header mid-conversation-tool-changes-2026-07-01 ที่ช่วยให้คุณเพิ่มหรือลบเครื่องมือระหว่างรอบได้โดยไม่ทำให้แคชของพรอมต์เป็นโมฆะ

Opus 5 ยังมอบหมายงานให้กับ subagents ได้ง่ายกว่า Opus 4.8 ในเวิร์กโหลดที่คำนึงถึงต้นทุน ให้ระบุขอบเขตอย่างชัดเจนใน system prompt ของคุณแทนที่จะไปพบในใบแจ้งหนี้

ขั้นตอนที่ 7: อ่านอ็อบเจกต์ usage เพื่อตรวจสอบการใช้แคช

การตอบสนองทุกครั้งมีอ็อบเจกต์ usage เป็นวิธีเดียวที่ซื่อสัตย์ในการยืนยันว่าการแคชพรอมต์ของคุณกำลังทำงานอยู่

"usage": {
  "input_tokens": 84,
  "cache_creation_input_tokens": 6421,
  "cache_read_input_tokens": 0,
  "output_tokens": 913
}

หากต้องการแคชบล็อก ให้ทำเครื่องหมายด้วย cache_control:

{
  "model": "claude-opus-5",
  "max_tokens": 4096,
  "system": [
    {
      "type": "text",
      "text": "<your long, stable instructions and reference material>",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [{"role": "user", "content": "Question one."}]
}

การเรียกใช้ครั้งแรก: cache_creation_input_tokens มีค่าไม่เป็นศูนย์ และ cache_read_input_tokens เป็น 0 การเรียกใช้ครั้งที่สองด้วย prefix เดียวกัน: ค่าเหล่านี้จะสลับกัน หากไม่สลับกัน แสดงว่า prefix ของคุณไม่เหมือนกันทุกไบต์ หรือต่ำกว่าค่าต่ำสุด

ค่าต่ำสุดนั้นเป็นข่าวดีของ Opus 5 การแคชพรอมต์จะเริ่มทำงานที่ 512 โทเค็น ซึ่งลดลงจาก 1,024 โทเค็นใน Opus 4.8 พรอมต์ที่สั้นเกินไปที่จะแคชก่อนหน้านี้ ตอนนี้สามารถแคชได้โดยไม่ต้องเปลี่ยนแปลงโค้ดเลย และการอ่านแคชจะคิดค่าบริการที่ 0.50 ดอลลาร์ต่อล้านโทเค็น เทียบกับอัตราอินพุตพื้นฐานที่ 5 ดอลลาร์ ยืนยัน cache_read_input_tokens ในชุดการทดสอบของคุณ เพื่อที่การแก้ไขพรอมต์ที่ทำให้แคชเสียหายอย่างเงียบๆ จะแสดงขึ้นเป็นการทดสอบที่ล้มเหลวแทนที่จะเป็นค่าใช้จ่ายที่เพิ่มขึ้น สำหรับตัวเลือกเพิ่มเติม โปรดดูคู่มือของเราเกี่ยวกับ การลดค่าใช้จ่าย Claude API ของคุณ

ทดสอบและดีบักขั้นตอนทั้งหมดใน Apidog

ทุกสิ่งที่กล่าวมาข้างต้นคือคำขอ HTTP ที่มีส่วนหัวการยืนยันตัวตน, JSON body, SSE stream, และการตอบสนองที่คุณต้องยืนยัน Apidog เป็นแพลตฟอร์มการพัฒนา API แบบครบวงจร และนี่คือประเภทของ endpoint ที่มันจัดการได้อย่างลงตัว: มันส่งคำขอ, จัดเก็บคีย์, แสดงผลสตรีม, และทดสอบการตอบสนอง มันไม่ได้ทำการอนุมานหรือกำหนดเส้นทางโมเดล; การเรียกยังคงส่งไปยัง Anthropic

การตั้งค่าที่คุ้มค่าตั้งแต่แรก:

สร้างคำขอ POST https://api.anthropic.com/v1/messages พร้อมส่วนหัวสามรายการ และดึงคีย์จากตัวแปรสภาพแวดล้อมแทนที่จะวางในโค้ด
บันทึกลงในคอลเลกชัน ทีมของคุณจะใช้รูปร่างคำขอที่ได้รับการยืนยันว่าดีแล้ว แทนที่จะให้แต่ละคนสร้างใหม่จากตัวอย่างในบล็อก
แยกสาขาตามระดับ effort ทำซ้ำคำขอโดยตั้งค่า output_config.effort เป็น low, medium, high และ xhigh ส่งพรอมต์เดียวกันไปยังแต่ละอัน และเปรียบเทียบคุณภาพเอาต์พุต, ความหน่วง, และจำนวนโทเค็นแบบเคียงข้างกัน นี่คือการทดสอบ effort ที่ Anthropic ขอให้คุณทำ โดยไม่ต้องเขียนโค้ดเพิ่มเติม
ดู SSE stream เปิด "stream": true และอ่านเหตุการณ์เมื่อมาถึงเพื่อยืนยันว่าคุณจัดการ thinking blocks และ text blocks แยกกัน
ตรวจสอบ payloads ของ tool-call เมื่อ stop_reason ส่งกลับมาเป็น tool_use อ็อบเจกต์ input ที่โมเดลสร้างขึ้นจะอยู่ที่นั่น ซึ่งเป็นวิธีที่คุณจะพบว่า input_schema ของคุณหลวมเกินไป
ยืนยันการตอบสนอง เพิ่มการตรวจสอบว่า stop_reason ไม่ใช่ max_tokens (สัญญาณการตัดของคุณ) และ cache_read_input_tokens มีค่ามากกว่าศูนย์ในการเรียกซ้ำ (สัญญาณการแคชของคุณ)

ดาวน์โหลด Apidog หากคุณต้องการทำตาม รูปแบบคอลเลกชันเดียวกันนี้ใช้ได้กับโมเดล Claude ใดๆ คุณจึงสามารถชี้ไปที่ Sonnet 5 หรือ คำขอ Opus 4.8 ที่มีอยู่ของคุณและเปรียบเทียบพฤติกรรมได้

ข้อผิดพลาดและสิ่งที่อาจพลาดที่คุณจะเจอจริงๆ

400 เมื่อ thinking: disabled บวกกับ effort xhigh หรือ max อธิบายไว้ข้างต้น ลด effort เป็น high หรือเปิดใช้งานการคิดใหม่
400 สำหรับ sampling parameters temperature, top_p, และ top_k ที่ไม่ใช่ค่าเริ่มต้นยังคงส่งคืน 400 ไม่เปลี่ยนแปลงจาก Opus 4.8 ให้ควบคุมผ่าน system prompt แทน
คำตอบถูกตัด stop_reason: "max_tokens" เมื่อเปิดใช้งานการคิด หมายถึงขีดจำกัดได้กลืนการตอบสนองของคุณไปแล้ว เพิ่ม max_tokens
Priority Tier ไม่รองรับใน Opus 5 Opus 4.8 ยังคงรองรับอยู่ หากการวางแผนความจุขององค์กรของคุณขึ้นอยู่กับสิ่งนี้ นั่นเป็นอุปสรรคที่แท้จริงที่ต้องจัดการก่อนที่คุณจะย้ายทราฟฟิก
ข้อความระบบระหว่างการสนทนาตอนนี้ทำงานได้ การเพิ่ม role: "system" ภายใน messages ได้รับการยอมรับใน Opus 5 ในขณะที่ Opus 4.8 จะคืนค่า 400 มีประโยชน์และควรทราบเพื่อที่คุณจะได้ไม่ต้องหาวิธีหลีกเลี่ยงอีกต่อไป
การตรวจสอบมากเกินไป Opus 5 ตรวจสอบงานของตัวเองโดยไม่ต้องถูกกระตุ้น หากคุณนำคำสั่ง "double-check your answer before responding" จาก 4.8 มาใช้ ให้ลบออก มันไม่ได้ให้ประโยชน์อะไรและยังเสียโทเค็นการคิดอีกด้วย

ขีดจำกัดที่แท้จริง

Opus 5 ไม่ใช่จุดสูงสุดของชุดผลิตภัณฑ์ Claude และควรกล่าวอย่างชัดเจน Fable 5 ยังคงครองตำแหน่ง "โมเดลที่มีความสามารถสูงสุดที่เผยแพร่ในวงกว้าง" ของ Anthropic โดยมีราคา 10 ดอลลาร์ต่อล้านโทเค็นอินพุต และ 50 ดอลลาร์ต่อล้านโทเค็นเอาต์พุต Opus 5 ยังตามหลัง Mythos 5 ในด้านการใช้ประโยชน์จากความปลอดภัยทางไซเบอร์และการวิจัยชีววิทยาแบบอัตโนมัติ ซึ่ง Anthropic ระบุเอง

การอ้างอิงเกณฑ์มาตรฐานในการเปิดตัว (ประมาณสองเท่าของ Opus 4.8 บน Frontier-Bench v0.1, ประมาณ 3 เท่าของโมเดลที่ดีที่สุดถัดไปบน ARC-AGI 3, อยู่ในช่วง 0.5% ของ Fable 5 บน CursorBench 3.2) เป็นตัวเลขของ Anthropic เองทั้งหมด และยังไม่ได้รับการตรวจสอบซ้ำอย่างอิสระ ณ วันที่ 25 กรกฎาคม 2026 โปรดอ่านว่าเป็นผลลัพธ์ที่ดำเนินการโดยผู้ขาย จากนั้นดำเนินการประเมินผลของคุณเอง การเปรียบเทียบ Opus 5 กับ Fable 5 จะอธิบายว่าช่องว่างราคาคุ้มค่าหรือไม่ และ โพสต์เปิดตัว ของ Anthropic เป็นแหล่งข้อมูลหลักสำหรับการอ้างสิทธิ์เหล่านั้น

คำถามที่พบบ่อย

ID โมเดลสำหรับ Claude Opus 5 คืออะไร? claude-opus-5 อย่างตรงตัว โดยไม่มีส่วนต่อท้ายวันที่ บน Amazon Bedrock คือ anthropic.claude-opus-5; Google Cloud และ Claude Platform บน AWS ใช้ ID ของผู้พัฒนาเอง

ทำไมคำขอ Opus 4.8 ที่เคยใช้งานได้ของฉันจึงเริ่มถูกตัดเมื่อใช้ Opus 5? การคิดเปิดใช้งานโดยค่าเริ่มต้นแล้ว max_tokens จำกัดทั้งโทเค็นการคิดและโทเค็นการตอบสนองรวมกัน ดังนั้นงบประมาณที่เคยพอดีกับคำตอบของคุณใน 4.8 อาจไม่พอดีกับการให้เหตุผลและคำตอบใน Opus 5 เพิ่ม max_tokens และตรวจสอบ stop_reason: "max_tokens"

ทำไมฉันถึงได้รับ 400 เมื่อฉันปิดการคิด? คุณเกือบจะจับคู่ thinking: {"type": "disabled"} กับ output_config.effort ที่ตั้งค่าเป็น xhigh หรือ max ชุดค่าผสมนั้นถูกปฏิเสธต่อคำขอ จำกัด effort ไว้ที่ high หรือเปิดใช้งานการคิดและลด effort แทน

ฉันจำเป็นต้องมี beta header สำหรับ context window 1M หรือไม่? ไม่จำเป็น ใน Opus 5, 1M โทเค็นเป็นทั้งค่าเริ่มต้นและค่าสูงสุด โดยไม่มี beta header และไม่มีค่าพรีเมียมสำหรับ long-context คุณต้องมี beta header output-300k-2026-03-24 เพื่อให้ได้เอาต์พุต 300k บน Batch API; Messages API จำกัดเอาต์พุตที่ 128k

ฉันสามารถนำการตั้งค่า effort ของ Opus 4.8 กลับมาใช้ใหม่ได้หรือไม่? Anthropic กล่าวว่าไม่ ระดับต่างๆ ได้รับการปรับเทียบใหม่ และ low และ medium มีความสามารถที่แข็งแกร่งขึ้นอย่างมีนัยสำคัญใน Opus 5 ทำการทดสอบใหม่กับชุดการประเมินของคุณเอง

Apidog รันโมเดลหรือไม่? ไม่ Apidog ส่ง, ตรวจสอบ, และทดสอบคำขอ HTTP; การอนุมานเกิดขึ้นที่ฝั่ง Anthropic มันจัดการคีย์, การสตรีม, payloads ของ tool-call, และการยืนยันการตอบสนองที่เกี่ยวข้องกับการเรียก