Blog

วิธีใช้ Claude Fable 5 API

เรียกใช้ Claude Fable 5 API ด้วยโค้ด Python, TypeScript และ curl ที่ใช้งานได้จริง: การสตรีมมิ่ง, การใช้เครื่องมือ, ข้อผิดพลาด, การคำนวณต้นทุน รวมถึงวิธีทดสอบใน Apidog

INEZA Felin-Michel

INEZA Felin-Michel

10 June 2026

วิธีใช้ Claude Fable 5 API

Apidog สำหรับองค์กร

การติดตั้งแบบ On-Premises

SSO & RBAC

รองรับมาตรฐาน SOC 2

สำรวจ Apidog Enterprise

Anthropic เปิดตัว Claude Fable 5 เมื่อวันที่ 9 มิถุนายน 2026 และหากคุณเขียนโค้ดเพื่อหาเลี้ยงชีพ Claude Fable 5 API คือส่วนที่คุณสนใจ API นี้ทำงานบน Messages API แบบเดียวกับที่คุณรู้จักอยู่แล้ว ดังนั้นสตริงโมเดลจึงเป็นสิ่งเดียวที่เปลี่ยนแปลงจริงๆ: claude-fable-5 คู่มือนี้จะแนะนำทุกการเรียกที่คุณต้องการเพื่อให้โค้ดทำงานและได้รับผลตอบกลับจริง ตั้งแต่คำขอ curl แบบบรรทัดเดียว ไปจนถึงการสตรีม การใช้เครื่องมือ การจัดการข้อผิดพลาด และการคำนวณค่าใช้จ่าย หากคุณเคยใช้งาน Claude มาก่อน รูปแบบจะรู้สึกคุ้นเคย หากคุณย้ายมาจากโมเดลเก่า การเปลี่ยนแปลงส่วนใหญ่คือการสลับสตริง เช่นเดียวกับ Claude Opus 4.8 API

สรุปโดยย่อ

รับ API key จาก Anthropic Console ตั้งค่าเป็น ANTHROPIC_API_KEY จากนั้นส่งคำขอ POST ไปยัง Messages API พร้อมกับ model: "claude-fable-5", ค่า max_tokens และอาร์เรย์ messages ใช้ Anthropic SDK อย่างเป็นทางการสำหรับ Python หรือ TypeScript หรือจะใช้ HTTP ดิบก็ได้ สตรีมเอาต์พุตที่มีความยาวเพื่อหลีกเลี่ยงการหมดเวลาของคำขอ ราคาอยู่ที่ $10 ต่อล้านโทเค็นอินพุต และ $50 ต่อล้านโทเค็นเอาต์พุต

ก่อนเริ่มต้น

คุณต้องเตรียมสี่สิ่งต่อไปนี้ก่อนการส่งคำขอครั้งแรกของคุณ:

  1. บัญชี Anthropic. ลงทะเบียนที่ console.anthropic.com Console คือที่ที่คุณจัดการคีย์ การใช้งาน และการเรียกเก็บเงิน
  2. API key. สร้างคีย์ใน Console ใต้ API Keys คัดลอกไว้เพียงครั้งเดียว คุณจะไม่เห็นอีก ปฏิบัติเสมือนเป็นรหัสผ่าน
  3. การชำระเงินหรือแผน Enterprise. Fable 5 มีให้บริการบน Claude API มาตรฐาน และมีให้บริการอย่างเต็มรูปแบบในแผน Enterprise แบบคิดตามการใช้งาน เพิ่มวิธีการชำระเงินหรือยืนยันว่าแผนของคุณครอบคลุมก่อนที่คุณจะส่งทราฟฟิก หากคุณยังตัดสินใจไม่ได้ว่า Fable 5 เหมาะสมกับกรณีการใช้งานของคุณหรือไม่ ภาพรวมของ Claude Fable 5 คืออะไร จะอธิบายจุดแข็งของโมเดลในภาษาง่ายๆ
  4. SDK (ไม่บังคับแต่แนะนำ). ติดตั้ง Anthropic SDK อย่างเป็นทางการสำหรับภาษาโปรแกรมของคุณ คุณยังสามารถเรียกใช้ HTTP endpoint ดิบด้วย curl หรือ HTTP client อื่นๆ ได้หากต้องการ

ตั้งค่าคีย์เป็นตัวแปรสภาพแวดล้อมเพื่อไม่ให้ปรากฏในซอร์สโค้ดของคุณ:

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

SDK ทั้งสองจะอ่าน ANTHROPIC_API_KEY จากตัวแปรสภาพแวดล้อมโดยอัตโนมัติ ดังนั้นคุณแทบจะไม่ต้องส่งค่านี้ในโค้ดเลย เก็บ key ของคุณให้พ้นจาก Git หาก key รั่วไหล ให้รีบเปลี่ยนทันทีใน Console

พฤติกรรมหนึ่งที่ควรรู้ล่วงหน้า: Fable 5 มาพร้อมระบบป้องกันที่จะส่งคำถามที่ละเอียดอ่อนบางส่วน (เช่น ความปลอดภัยทางไซเบอร์ ชีววิทยาและเคมี และความพยายามในการกลั่นโมเดล) ไปยัง Claude Opus 4.8 แทน การดำเนินการนี้เกิดขึ้นน้อยกว่า 5% ของเซสชัน คุณไม่จำเป็นต้องกำหนดค่าใดๆ สำหรับสิ่งนี้ แต่มันอธิบายถึงการตอบกลับบางครั้งที่ปรากฏว่ามาจากโมเดลที่แตกต่างกัน ดูรายละเอียดเพิ่มเติมได้ในส่วนการจัดการข้อผิดพลาด

การเรียกใช้ Claude Fable 5 API ครั้งแรกของคุณ

เริ่มต้นด้วย curl เพื่อให้คุณสามารถเห็นคำขอและผลตอบกลับดิบโดยไม่มีสิ่งใดมาขัดขวาง Endpoint คือ POST https://api.anthropic.com/v1/messages ซึ่งอยู่ใน เอกสารอ้างอิง Anthropic Messages API และต้องการส่วนหัวสามส่วนพร้อมกับเนื้อหา JSON

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-fable-5","max_tokens":1024,"messages":[{"role":"user","content":"Summarize what makes a good REST API in 3 bullet points."}]}'

ส่วนหัวสามส่วนที่สำคัญที่นี่คือ x-api-key ซึ่งบรรจุ key ของคุณ anthropic-version ระบุเวอร์ชัน API (2023-06-01 เป็นค่าเสถียรปัจจุบัน) content-type บอกเซิร์ฟเวอร์ว่าคุณกำลังส่ง JSON เนื้อหาของคำขอมีสามฟิลด์ที่จำเป็น: model, max_tokens และ messages นี่คือข้อตกลงทั้งหมด

ผลตอบกลับจะมาในรูปแบบออบเจกต์ JSON ส่วนที่คุณสนใจคือ content ซึ่งเป็นรายการของบล็อกต่างๆ:

{
  "id": "msg_01ABC...",
  "type": "message",
  "role": "assistant",
  "model": "claude-fable-5",
  "content": [
    { "type": "text", "text": "- Predictable, resource-oriented URLs..." }
  ],
  "stop_reason": "end_turn",
  "usage": { "input_tokens": 18, "output_tokens": 96 }
}

content เป็นรายการ ไม่ใช่สตริง เนื่องจากผลตอบกลับเดียวสามารถผสมผสานข้อความ บล็อกการใช้เครื่องมือ และบล็อกการคิดได้ ตรวจสอบ type ของแต่ละบล็อกเสมอก่อนที่คุณจะอ่าน text stop_reason จะบอกคุณว่าทำไมโมเดลจึงหยุดทำงาน (end_turn คือการสิ้นสุดที่สมบูรณ์) และ usage จะให้จำนวนโทเค็นที่คุณจะใช้สำหรับการคำนวณค่าใช้จ่ายในภายหลัง

การเรียกใช้ Fable 5 จาก Python

Anthropic Python SDK อย่างเป็นทางการ ช่วยลดความซับซ้อนของส่วนหัวและ JSON ติดตั้งก่อน:

pip install anthropic

นี่คือการเรียกใช้งานพื้นฐาน Client จะอ่าน key ของคุณจากสภาพแวดล้อม ดังนั้นคุณไม่จำเป็นต้องส่งค่าเข้าไป:

import anthropic

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

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize what makes a good REST API."}],
)

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

รูปแบบนี้สะท้อนการเรียกใช้ curl คุณส่ง model, max_tokens และ messages และคุณจะได้รับผลตอบกลับที่มี content เป็นรายการของบล็อก ลูปจะตรวจสอบ block.type == "text" เพื่อให้คุณไม่พลาดบล็อกที่ไม่ใช่ข้อความ

การเพิ่ม System Prompt

System prompt กำหนดบทบาทของโมเดลและกฎพื้นฐานสำหรับการสนทนาทั้งหมด ส่งเป็นฟิลด์ system แยกจาก messages:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=2048,
    system="You are a senior backend engineer. Be concise and use code examples.",
    messages=[{"role": "user", "content": "Write a Flask route that validates a JSON body."}],
)

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

System prompt เป็นตำแหน่งที่เหมาะสมสำหรับบุคลิก กฎรูปแบบเอาต์พุต และข้อจำกัดที่คุณต้องการให้คงอยู่ตลอดการสนทนา รักษามันให้คงที่ เพราะการเปลี่ยนมันในทุกคำขอจะทำให้การแคช prompt ไม่มีผล หากคุณเพิ่มในภายหลัง

การสตรีมเอาต์พุตที่มีความยาว

สำหรับอะไรก็ตามที่สร้างคำตอบที่มีความยาว ให้ทำการสตรีม การสตรีมจะส่งโทเค็นในขณะที่สร้างขึ้น ดังนั้นคุณจะเห็นความคืบหน้าได้ทันที และหลีกเลี่ยงการหมดเวลาของคำขอที่เกิดขึ้นกับผลตอบกลับขนาดใหญ่ที่ไม่ได้สตรีม งานระยะยาวของ Fable 5 ทำให้เป็นตัวเลือกเริ่มต้นสำหรับปริมาณงานจริง:

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Explain idempotency keys for payment APIs."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()

print(f"\n\nTokens: {final.usage.output_tokens}")

stream.text_stream จะส่งส่วนข้อความออกมาเมื่อมาถึง flush=True มีความสำคัญเพื่อให้แต่ละส่วนพิมพ์ออกมาทันทีแทนที่จะถูกบัฟเฟอร์ เมื่อสตรีมเสร็จสิ้น stream.get_final_message() จะส่งข้อความที่ประกอบเสร็จสมบูรณ์ให้คุณ รวมถึงตัวเลข usage สุดท้าย ดังนั้นคุณจึงได้รับประสบการณ์ผู้ใช้แบบสตรีมและออบเจกต์เต็มรูปแบบโดยไม่ต้องส่งคำขอซ้ำ

การเรียกใช้ Fable 5 จาก TypeScript / Node

Node SDK มีรูปแบบเดียวกัน ติดตั้งได้เลย:

npm install @anthropic-ai/sdk

จากนั้นทำการเรียกใช้งาน Client จะอ่าน ANTHROPIC_API_KEY จากสภาพแวดล้อม เช่นเดียวกับ Python:

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

const client = new Anthropic(); // reads ANTHROPIC_API_KEY

const msg = await client.messages.create({
  model: "claude-fable-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "List 3 common API security mistakes." }],
});

console.log(msg.content);

msg.content คือรายการของบล็อกเดียวกันกับที่คุณเห็นใน Python และ curl หากต้องการดึงเฉพาะข้อความ ให้อ้างอิงประเภทบล็อก:

const text = msg.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);

การสตรีมทำงานในลักษณะเดียวกับ Python ใช้ client.messages.stream({...}) และวนซ้ำเหตุการณ์ หรือรอ finalMessage() สำหรับผลลัพธ์ที่ประกอบเสร็จสมบูรณ์ หากคุณกำลังเชื่อมต่อสิ่งนี้เข้ากับแชทส่วนหน้า ให้สตรีมจากเส้นทางเซิร์ฟเวอร์และส่งส่วนต่างๆ ไปยังเบราว์เซอร์ นิสัยการทดสอบเดียวกันนี้ใช้ได้ไม่ว่าคุณจะพัฒนาด้วย Node หรือ Python และเครื่องมืออย่าง Apidog ทำให้การตรวจสอบสัญญาเป็นเรื่องง่ายก่อนที่คุณจะเขียนโค้ดไคลเอนต์ใดๆ ซึ่งเป็นเวิร์กโฟลว์เดียวกันกับที่กล่าวถึงใน การทดสอบ ChatGPT API ด้วย Apidog

การใช้เครื่องมือ (การเรียกฟังก์ชัน) กับ Fable 5

การใช้เครื่องมือช่วยให้ Fable 5 สามารถเรียกใช้ฟังก์ชันที่คุณกำหนดได้ คุณอธิบายเครื่องมือด้วย JSON schema โมเดลจะตัดสินใจว่าจะเรียกใช้เมื่อใด และคุณจะรันฟังก์ชันจริงและป้อนผลลัพธ์กลับไป Fable 5 มีความสามารถในการใช้เครื่องมือที่แข็งแกร่ง ซึ่งเป็นเหตุผลว่าทำไมจึงเหมาะกับวงจรของเอเจนต์เป็นอย่างดี

กำหนดเครื่องมือด้วยชื่อ คำอธิบาย และ input_schema:

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

ส่ง tools ไปยังคำขอในลักษณะเดียวกับที่คุณส่ง messages:

messages = [{"role": "user", "content": "What's the status of order A1855?"}]

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

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

if response.stop_reason == "tool_use":
    tool_use = next(b for b in response.content if b.type == "tool_use")

    # Run your real function with the model's chosen input
    result = lookup_order(tool_use.input["order_id"])  # your code

    messages.append({"role": "assistant", "content": response.content})
    messages.append({
        "role": "user",
        "content": [{
            "type": "tool_result",
            "tool_use_id": tool_use.id,
            "content": result,
        }],
    })

    # Send the result back; the model now answers using it
    followup = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )

รายละเอียดสำคัญคือ tool_use_id: บล็อก tool_result ต้องอ้างอิงถึง id ที่แน่นอนจากบล็อก tool_use เพื่อให้โมเดลทราบว่าผลลัพธ์ของคุณตอบสนองการเรียกใด สำหรับเอเจนต์หลายขั้นตอน คุณสามารถห่อสิ่งนี้ในลูปที่ทำงานต่อไปจนกว่า stop_reason จะเป็น end_turn Python SDK ยังมาพร้อมกับตัวรันเครื่องมือที่จัดการลูปให้คุณ แต่เวอร์ชันแบบ manual ข้างต้นแสดงสิ่งที่เกิดขึ้นภายใต้พื้นฐานและให้พื้นที่สำหรับการเพิ่มเกตการอนุมัติหรือการบันทึก

การคิดและพยายามแบบปรับเปลี่ยนได้

Fable 5 รองรับการคิดแบบปรับเปลี่ยนได้ ซึ่งโมเดลจะตัดสินใจด้วยตนเองว่าจะให้เหตุผลลึกซึ้งเพียงใดก่อนตอบ เป็นทางเลือก คุณสามารถเปิดใช้งานได้โดยส่ง thinking และปรับความลึกโดยรวมและการใช้โทเค็นด้วย output_config:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},  # low | medium | high
    messages=[{"role": "user", "content": "Design a retry strategy for a flaky webhook receiver."}],
)

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

การจัดการข้อผิดพลาดและการเปลี่ยนไปใช้ระบบป้องกัน

การผสานรวมที่แท้จริงจะต้องจัดการกับความล้มเหลวอย่างหมดจด SDK จะส่งข้อยกเว้นแบบมีประเภท ดังนั้นให้จับคลาสที่เฉพาะเจาะจงแทนที่จะจับสตริงข้อผิดพลาด สามข้อผิดพลาดที่คุณจะพบบ่อยที่สุดคือ HTTP 401, 429 และ 400:

import anthropic

client = anthropic.Anthropic()

try:
    response = client.messages.create(
        model="claude-fable-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Explain CORS preflight requests."}],
    )
except anthropic.AuthenticationError:
    # 401: bad or missing API key. Check ANTHROPIC_API_KEY.
    print("Invalid API key. Rotate it in the Console and re-export.")
except anthropic.RateLimitError as e:
    # 429: too many requests. Back off and retry.
    retry_after = e.response.headers.get("retry-after", "60")
    print(f"Rate limited. Retry after {retry_after}s.")
except anthropic.BadRequestError as e:
    # 400: malformed request (bad params, empty messages, wrong shape).
    print(f"Bad request: {e.message}")

นี่คือความหมายของแต่ละข้อผิดพลาดและวิธีการแก้ไข:

มาถึงระบบป้องกันสำรอง Fable 5 จะส่งคำถามที่ละเอียดอ่อนบางส่วน (ความปลอดภัยทางไซเบอร์ ชีววิทยาและเคมี และความพยายามในการกลั่นโมเดล) ไปยัง Claude Opus 4.8 แทนที่จะตอบโดยตรง สิ่งนี้เกิดขึ้นน้อยกว่า 5% ของเซสชัน นี่ไม่ใช่ข้อผิดพลาด และคำขอของคุณยังคงสำเร็จ แต่การตอบกลับอาจติดแท็กด้วยโมเดลที่แตกต่างกัน หากคุณบันทึกหรือยืนยันบน response.model อย่าให้เกิดข้อผิดพลาดรุนแรงเมื่อไม่ใช่ claude-fable-5; คำขอได้รับการจัดการแล้ว เพียงแต่ใช้โมเดลที่แตกต่างกันภายใต้เบื้องหลัง หากแอปพลิเคชันของคุณต้องการทราบอย่างเคร่งครัดว่าโมเดลใดตอบกลับ ให้อ่าน response.model จากออบเจกต์ที่ส่งกลับมา แทนที่จะสันนิษฐานว่าตรงกับสิ่งที่คุณส่งไป

การประเมินค่าใช้จ่ายต่อคำขอ

ราคาอยู่ที่ $10 ต่อล้านโทเค็นอินพุต และ $50 ต่อล้านโทเค็นเอาต์พุต ทุกการตอบกลับจะระบุจำนวนที่แน่นอนใน usage ดังนั้นคุณจึงสามารถคำนวณค่าใช้จ่ายต่อคำขอได้อย่างแม่นยำแทนที่จะคาดเดา:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a SQL query to find duplicate emails."}],
)

input_tokens = response.usage.input_tokens
output_tokens = response.usage.output_tokens

input_cost = input_tokens / 1_000_000 * 10
output_cost = output_tokens / 1_000_000 * 50
total = input_cost + output_cost

print(f"Input:  {input_tokens} tokens  = ${input_cost:.6f}")
print(f"Output: {output_tokens} tokens = ${output_cost:.6f}")
print(f"Total:  ${total:.6f}")

โทเค็นเอาต์พุตมีราคาแพงกว่าโทเค็นอินพุตถึงห้าเท่า ดังนั้นวิธีที่ประหยัดที่สุดคือการรักษาการตอบกลับให้กระชับ คำขอที่มีโทเค็นอินพุต 2,000 และโทเค็นเอาต์พุต 500 จะมีค่าใช้จ่าย 2000 / 1M * $10 + 500 / 1M * $50 ซึ่งเท่ากับ $0.02 + $0.025 = $0.045 คูณด้วยปริมาณคำขอของคุณเพื่อกำหนดงบประมาณ หากค่าใช้จ่ายเอาต์พุตมีสัดส่วนใหญ่ในบิลของคุณ ให้จำกัด max_tokens และขอคำตอบที่กระชับใน system prompt การกำหนดราคาเอาต์พุตเป็นการคำนวณแบบเดียวกับที่คุณใช้สำหรับโมเดล Claude Opus 4.8 เพียงแค่ใช้ตัวเลขของ Fable 5

ทดสอบและดีบัก Claude Fable 5 API ด้วย Apidog

ก่อนที่คุณจะเขียนโค้ดไคลเอนต์ การส่งคำขอด้วยตนเองสองสามครั้งและดูว่ามีอะไรกลับมาบ้างนั้นคุ้มค่า Apidog คือไคลเอนต์ API ที่สร้างขึ้นมาเพื่อการนี้: คุณส่งคำขอจริงไปยัง https://api.anthropic.com/v1/messages ตรวจสอบการตอบกลับแบบสตรีม และบันทึกคำขอเพื่อให้ทั้งทีมของคุณทำงานจากข้อกำหนดเดียวกัน นี่คือเส้นทางที่ชัดเจนตั้งแต่เริ่มต้นจนถึงคำขอที่ใช้งานได้และบันทึกไว้

  1. สร้างคำขอ. ใน Apidog ให้สร้างคำขอ HTTP ใหม่ ตั้งค่าเมธอดเป็น POST และวาง URL https://api.anthropic.com/v1/messages นี่คือ endpoint เดียวกันกับที่ทุกตัวอย่างในคู่มือนี้ใช้
  2. จัดเก็บ key ของคุณเป็นตัวแปรสภาพแวดล้อม. สร้างตัวแปรสภาพแวดล้อมของ Apidog ตั้งชื่อเช่น anthropic_api_key และวาง key ของคุณเป็นค่าลับ การเก็บ key ไว้ในสภาพแวดล้อมหมายความว่าจะไม่ปรากฏในคำขอที่บันทึกไว้และไม่อยู่ในการส่งออกใดๆ ที่คุณแชร์
  3. ตั้งค่าส่วนหัว (headers). เพิ่ม x-api-key ด้วยค่า {{anthropic_api_key}} จากนั้น anthropic-version: 2023-06-01 และ content-type: application/json หากคุณต้องการตัวแปรลับแบบ Bearer-style ให้เก็บโทเค็นในลักษณะเดียวกันและอ้างอิงด้วยไวยากรณ์ {{...}} เพื่อให้ค่าดิบไม่ปรากฏในคำขอ
  4. เพิ่มเนื้อหา JSON. ใส่ข้อมูล payload ขั้นต่ำ: {"model": "claude-fable-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "Explain idempotency keys for payment APIs."}]} ส่งคำขอและอ่านผลตอบกลับ คุณควรเห็นบล็อก content, stop_reason และ usage ในแผงผลตอบกลับทันที
  5. ดูผลตอบกลับแบบสตรีม. ตั้งค่า "stream": true ในเนื้อหาและส่งอีกครั้ง Apidog จะแสดงผลเหตุการณ์ที่ส่งมาจากเซิร์ฟเวอร์เมื่อมาถึง ดังนั้นคุณจึงสามารถดูโทเค็นที่สตรีมเข้ามาและยืนยันว่าตรรกะการสตรีมของคุณตรงกับสิ่งที่ API ส่งจริง ก่อนที่คุณจะสร้างมันในแอป
  6. บันทึกและสร้างโค้ด. บันทึกคำขอลงในคอลเลกชันเพื่อให้เพื่อนร่วมทีมสามารถนำกลับมาใช้ใหม่ได้ จากนั้นใช้ฟังก์ชันการสร้างโค้ดของ Apidog เพื่อส่งออกโค้ดที่ใช้งานได้ใน Python, JavaScript, curl หรือภาษาอื่นๆ นั่นจะทำให้คุณมีจุดเริ่มต้นที่ผ่านการทดสอบแล้ว แทนที่จะเป็นไฟล์เปล่า

ขั้นตอนการทำงานนี้เป็นวิธีที่เร็วที่สุดในการเรียนรู้รูปแบบการตอบกลับที่แน่นอนของ API และการดีบักคำขอที่มีปัญหาในแอปของคุณ เนื่องจากคุณสามารถเปรียบเทียบคำขอจากโค้ดของคุณกับคำขอที่ทราบว่าดีแล้วแบบเคียงข้างกัน เมื่อคุณพร้อมที่จะตั้งค่าแล้ว ดาวน์โหลด Apidog และเริ่มต้นด้วยเนื้อหาขั้นต่ำด้านบน

ดาวน์โหลด Apidog

ฝึกการออกแบบ API แบบ Design-first ใน Apidog

ค้นพบวิธีที่ง่ายขึ้นในการสร้างและใช้ API

ลงทะเบียนฟรีดาวน์โหลด