MiniMax M3 เป็นโมเดลการให้เหตุผลและการเขียนโค้ดที่ล้ำสมัย ด้วย Context Window ที่รองรับสูงสุด 1,000,000 โทเคน ตัวเลขนี้คือจุดเด่นสำคัญ คุณสามารถป้อนข้อมูล เช่น Repository ทั้งหมด, Log ตลอดทั้งสัปดาห์, หรือเอกสารการออกแบบที่ยาวเหยียด แล้วให้โมเดลวิเคราะห์ข้อมูลทั้งหมดได้ในการเรียกใช้เพียงครั้งเดียว หากต้องการทราบข้อมูลพื้นฐานว่าโมเดลนี้คืออะไรและเหมาะกับอะไร โปรดอ่าน MiniMax M3 คืออะไร ก่อน
คู่มือนี้เป็นฉบับปฏิบัติจริง คุณจะได้รับ API Key, ส่งคำขอแรกของคุณด้วยสามวิธีที่แตกต่างกัน และทดสอบทุกขั้นตอนใน Apidog เพื่อให้คุณเห็นคำขอและคำตอบดิบ ก่อนที่จะนำไปใช้ในโค้ดของคุณ ดาวน์โหลด Apidog หากคุณต้องการทำตาม
เอกสารอ้างอิงอย่างเป็นทางการอยู่ที่ เอกสาร API ของ MiniMax เปิดค้างไว้ในแท็บ
สิ่งที่คุณต้องมี
- บัญชี MiniMax ที่ platform.minimax.io
- API Key (เราจะสร้างให้ด้านล่าง)
- วิธีการชำระเงิน: เครดิตแบบ Pay-as-you-go หรือแผน Token แบบสมัครสมาชิก ทั้งสองวิธีใช้ได้กับ Endpoint เดียวกัน
คุณไม่จำเป็นต้องติดตั้งสิ่งอื่นใดเพิ่มเติมสำหรับตัวอย่าง Curl สำหรับตัวอย่าง SDK คุณจะต้องมี Python 3.8 ขึ้นไป หรือ Node 18 ขึ้นไป
ขั้นตอนที่ 1: รับ API Key ของคุณ
เข้าสู่ระบบที่ platform.minimax.io, เปิดส่วน API Keys ของบัญชีของคุณ และสร้าง Key ใหม่ MiniMax ออกข้อมูลประจำตัวสองประเภท ซึ่งมีความแตกต่างกัน:
- API Key ทั่วไปจะเรียกเก็บเงินจากยอดคงเหลือแบบ Pay-as-you-go ของคุณ
- Subscription Key จะใช้เครดิตโทเคนจากแผนของคุณ (Plus, Max หรือ Ultra) เมื่อโทเคนของแผนหมด การเรียกใช้ด้วย Key นั้นจะหยุดลงจนกว่าแผนจะต่ออายุ หรือคุณเปลี่ยนไปใช้ Key แบบ Pay-as-you-go
เลือกแบบที่ตรงกับวิธีการเรียกเก็บเงินที่คุณต้องการ คัดลอก Key เพียงครั้งเดียวและเก็บไว้ คุณจะไม่เห็นมันอีก
อย่าแปะ Key โดยตรงใน Source Code ให้ส่งออกเป็น Environment Variable แทน:
export MINIMAX_API_KEY="your-key-here"
วิธีนี้ช่วยให้ข้อมูลลับไม่อยู่ใน Git History ของคุณ และไม่อยู่ในไฟล์ที่คุณอาจแชร์ หากคุณทำงานกับ API Key ภายใน Editor ของคุณ กฎสุขอนามัยเดียวกันก็ใช้ได้ที่นั่น เราได้พูดถึงการรั่วไหลทั่วไปใน ความปลอดภัยของ API Key ในส่วนขยาย VS Code
ขั้นตอนที่ 2: ส่งคำขอแรกของคุณ
Base URL คือ https://api.minimax.io/v1 และ API Chat อยู่ที่ POST https://api.minimax.io/v1/chat/completions การยืนยันตัวตนคือ Bearer Token: Authorization: Bearer $MINIMAX_API_KEY String ID ของโมเดลคือ MiniMax-M3
นี่คือการเรียกใช้ด้วย Curl ที่มีประโยชน์และสั้นที่สุด งานจริงคือการขอให้โมเดล Refactor ฟังก์ชัน:
curl https://api.minimax.io/v1/chat/completions \
-H "Authorization: Bearer $MINIMAX_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"MiniMax-M3","messages":[{"role":"user","content":"Refactor this function to be async."}]}'
คุณมีสามวิธีในการเรียกใช้ M3 MiniMax แนะนำ Anthropic SDK แต่ OpenAI SDK และ Raw HTTP ก็สามารถทำงานกับ Endpoint เดียวกันได้ ใช้ตัวใดก็ได้ที่ Stack ของคุณรองรับอยู่แล้ว
นี่คือ OpenAI SDK ใน Python การเปลี่ยนแปลงเพียงอย่างเดียวจากการตั้งค่า OpenAI ปกติคือ base_url:
from openai import OpenAI
client = OpenAI(
base_url="https://api.minimax.io/v1",
api_key="YOUR_API_KEY",
)
response = client.chat.completions.create(
model="MiniMax-M3",
messages=[
{"role": "user", "content": "Refactor this function to be async."}
],
)
print(response.choices[0].message.content)
และแนวคิดเดียวกันใน Node โดยเพียงแค่เปลี่ยน Base URL:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.minimax.io/v1",
apiKey: process.env.MINIMAX_API_KEY,
});
const response = await client.chat.completions.create({
model: "MiniMax-M3",
messages: [
{ role: "user", content: "Refactor this function to be async." },
],
});
console.log(response.choices[0].message.content);
หากคุณเคยใช้ Qwen 3.7 API รูปแบบนี้จะคุ้นเคยกันดี โมเดลล้ำสมัยส่วนใหญ่ตอนนี้เปิดเผยพื้นผิวที่เข้ากันได้กับ OpenAI ดังนั้นค่าใช้จ่ายในการย้ายข้อมูลจึงเป็นเพียงบรรทัดเดียว เอกสาร OpenAI Python SDK และ เอกสาร Anthropic SDK ครอบคลุมตัวเลือกไคลเอนต์ทั้งหมด
ขั้นตอนที่ 3: ทดสอบและตรวจสอบใน Apidog
ก่อนที่คุณจะฝังการเรียกใช้ API นี้ลงในแอปพลิเคชัน ให้ลองส่งด้วยตนเองและอ่าน Response ดิบ นั่นคือจุดที่ Apidog เข้ามามีบทบาทสำคัญ
- สร้าง HTTP request ใหม่และตั้งค่า method เป็น
POSTพร้อม URLhttps://api.minimax.io/v1/chat/completions - เปิดแผง Environments และเพิ่มตัวแปรชื่อ
MINIMAX_API_KEYโดยใช้ Key ของคุณเป็นค่า เก็บเป็น Environment Variable เพื่อไม่ให้Key อยู่ใน Request Body หรือใน Collection ที่คุณแชร์ - ใน Request Headers เพิ่ม
Authorizationด้วยค่าBearer {{MINIMAX_API_KEY}}Apidog จะแทนที่ตัวแปรเมื่อส่ง - ตั้งค่า Body เป็น Raw JSON และวาง Payload เดียวกันจากตัวอย่าง Curl
- กด Send และดูแผง Response
[ภาพหน้าจอ: คำขอและคำตอบของ MiniMax-M3 ใน Apidog]
การเก็บ Token เป็น Environment Variable หมายความว่าคุณสามารถแชร์ Request กับเพื่อนร่วมทีมได้โดยไม่เปิดเผยข้อมูลลับ และคุณสามารถสลับ Key (แบบ Pay-as-you-go กับแบบสมัครสมาชิก) ได้โดยการเปลี่ยนตัวแปรเพียงตัวเดียว เมื่อคุณเปิดใช้งาน Streaming ในภายหลัง Apidog จะแสดง Server-sent Events เมื่อมาถึง เพื่อให้คุณยืนยันรูปแบบ Stream ได้ก่อนที่จะเขียนโค้ดสำหรับ Parse ใดๆ การตรวจสอบ Response ด้วยตนเองจะช่วยให้ตรวจพบความประหลาดใจของ Schema ได้ตั้งแต่เนิ่นๆ ซึ่งเป็นหัวใจสำคัญของการทดสอบ Endpoint ก่อนที่คุณจะเชื่อถือมัน
ขั้นตอนที่ 4: เปิดและปิดการให้เหตุผล (Thinking)
M3 เป็นโมเดลการให้เหตุผล โดยค่าเริ่มต้นจะส่งคืนคำตอบสุดท้าย คุณยังสามารถขอให้มันแสดงการให้เหตุผลระหว่างกระบวนการ ซึ่งมีประโยชน์เมื่อคุณต้องการ Debug ว่าทำไมมันถึงได้ข้อสรุปนั้น หรือป้อนการให้เหตุผลนั้นเข้าสู่ขั้นตอนการตรวจสอบ
ด้วย OpenAI SDK ให้ส่ง reasoning_split ผ่าน extra_body:
from openai import OpenAI
client = OpenAI(
base_url="https://api.minimax.io/v1",
api_key="YOUR_API_KEY",
)
response = client.chat.completions.create(
model="MiniMax-M3",
messages=[
{"role": "user", "content": "Refactor this function to be async."}
],
extra_body={"reasoning_split": True},
)
print(response.choices[0].message.reasoning_details[0]["text"]) # the thinking
print(response.choices[0].message.content) # the final answer
เมื่อ reasoning_split เปิดอยู่ ข้อความการให้เหตุผลจะถูกส่งกลับมาที่ response.choices[0].message.reasoning_details[0]["text"] และคำตอบสุดท้ายจะอยู่ที่ response.choices[0].message.content แยกทั้งสองส่วนออกจากกันใน UI ของคุณ แสดงคำตอบให้ผู้ใช้เห็น และเก็บการให้เหตุผลไว้สำหรับ Log หรือการตรวจสอบ
เปิดการให้เหตุผลสำหรับปัญหาที่ซับซ้อน: การ Refactor หลายขั้นตอน, การล่า Bug ที่ยาก, หรือสิ่งใดก็ตามที่คุณต้องการตรวจสอบห่วงโซ่การทำงาน ปิดการให้เหตุผลสำหรับการเรียกใช้ที่ง่ายและอ่อนไหวต่อ Latency ซึ่งโทเคนการให้เหตุผลเพิ่มเติมจะเสียเวลาและเงินที่คุณไม่จำเป็นต้องใช้
ขั้นตอนที่ 5: ทำงานกับ Context ขนาด 1M โทเคน
Context Window ขนาดใหญ่เป็นเหตุผลที่ทำให้ต้องใช้ M3 คุณสามารถวางไฟล์ Log ทั้งหมดและถามคำถามเดียวจากข้อมูลทั้งหมดนั้นได้:
with open("production-2026-05-30.log") as f:
log_text = f.read()
response = client.chat.completions.create(
model="MiniMax-M3",
messages=[
{
"role": "user",
"content": f"Find the root cause of the 502 spike at 14:20 UTC.\n\n{log_text}",
}
],
)
จุดสำคัญเกี่ยวกับการเรียกเก็บเงินที่คุณต้องรู้ MiniMax คิดอัตรามาตรฐานสำหรับการเรียกใช้ที่มี Input Token 512K หรือน้อยกว่า และอัตรา Long-Context ที่สูงขึ้นเมื่อ Input เกิน 512K โทเคน ดังนั้นการข้ามจาก Prompt 400K โทเคน ไปยัง Prompt 600K โทเคน จึงไม่ใช่เชิงเส้นตรง มันข้ามเกณฑ์ราคาแล้ว
ข้อคิดที่นำไปใช้ได้จริง: อย่าโยนโทเคนเป็นล้านๆ เข้าไปใน Context จนเป็นนิสัย ส่งเฉพาะส่วนที่โมเดลต้องการ หากคุณกำลังเชื่อมโยงการเรียกใช้หลายครั้งใน Agent การตัด Context ต่อการเรียกใช้แต่ละครั้งเป็นหนึ่งในวิธีที่สำคัญที่สุดในการลดค่าใช้จ่ายของคุณ เราจะเจาะลึกเรื่องนี้ใน วิธีลดค่าใช้จ่ายโทเคนของ Agent
ขั้นตอนที่ 6: การเรียกใช้เครื่องมือ (Tool Calling) และ Input แบบ Multimodal
M3 รองรับการเรียกใช้เครื่องมือ (Tool Calling) และ Input แบบ Multimodal ดังนั้นจึงสามารถขับเคลื่อน Agent และอ่านรูปภาพได้ ไม่ใช่แค่ข้อความเท่านั้น
สำหรับการเรียกใช้เครื่องมือ คุณประกาศเครื่องมือที่โมเดลได้รับอนุญาตให้เรียกใช้ จากนั้นจัดการการเรียกใช้ที่ส่งคืนมา:
tools = [
{
"type": "function",
"function": {
"name": "run_tests",
"description": "Run the test suite for a given module path.",
"parameters": {
"type": "object",
"properties": {
"module": {"type": "string"},
},
"required": ["module"],
},
},
}
]
response = client.chat.completions.create(
model="MiniMax-M3",
messages=[
{"role": "user", "content": "Fix the failing test in auth/session.py and confirm it passes."}
],
tools=tools,
)
เมื่อโมเดลตัดสินใจเรียกใช้เครื่องมือ Response จะมี Array tool_calls โค้ดของคุณจะรันฟังก์ชัน, เพิ่มผลลัพธ์เป็นข้อความ tool และเรียกใช้ API อีกครั้งเพื่อให้โมเดลสามารถดำเนินการต่อได้ การจัดการ Handshake นี้ให้ถูกต้องเป็นจุดที่ Bug ของ Agent ส่วนใหญ่อยู่ รูปแบบการเชื่อมต่อและโหมดความล้มเหลวเป็นสิ่งที่ควรอ่านก่อนที่คุณจะนำไปใช้งานจริง: การเชื่อมต่อเครื่องมือใน Workflow แบบ Agentic
Apidog ก็ช่วยในส่วนนี้ด้วย คุณสามารถเล่นซ้ำการแลกเปลี่ยนแบบ Multi-turn ทั้งหมด (คำขอเริ่มต้น, Response การเรียกใช้เครื่องมือ, ผลลัพธ์เครื่องมือของคุณ, การติดตามผล) เป็น Request ที่บันทึกแยกกัน เพื่อให้คุณสามารถตรวจสอบแต่ละขั้นตอนได้ตั้งแต่ต้นจนจบ แทนที่จะคาดเดาภายใน Agent Runtime ของคุณ
สำหรับ Input แบบ Multimodal คุณส่งเนื้อหารูปภาพใน Array ข้อความเดียวกัน ควบคู่ไปกับ Text Prompt ของคุณ โดยปฏิบัติตามรูปแบบ Content-parts มาตรฐาน ตรวจสอบ เอกสารอ้างอิง API สำหรับชื่อฟิลด์ที่แน่นอน เนื่องจากสิ่งเหล่านี้มีการพัฒนาเร็วกว่า Endpoint ข้อความ
ราคาและระดับบริการ
สองปัจจัยที่แตกต่างกันควบคุมสิ่งที่คุณจ่ายและความเร็วในการให้บริการ
แผน Token กำหนดงบประมาณเครดิตของคุณ ระดับการสมัครสมาชิก ได้แก่ Plus ที่ $20, Max ที่ $50 และ Ultra ที่ $120 ซึ่งแต่ละแผนจะรวมเครดิตโทเคนจำนวนมากขึ้นซึ่งจะถูกหักออกโดย Subscription Key ของคุณ Pay-as-you-go จะเรียกเก็บเงิน API Key ทั่วไปจากยอดคงเหลือของคุณแทน
ระดับบริการกำหนดลำดับความสำคัญในการจัดคิว มีสองระดับคือ: standard (ค่าเริ่มต้น) และ priority Standard เหมาะสำหรับ Workload ส่วนใหญ่ Priority ใช้สำหรับทราฟฟิกที่อ่อนไหวต่อ Latency หรือมีข้อผูกมัดด้าน SLA ซึ่งไม่สามารถรอคิวอยู่ข้างหลังผู้อื่นได้
เมื่อนำมารวมกับอัตรา Standard เทียบกับ Long-Context จากขั้นตอนที่ 5 ค่าใช้จ่ายที่แท้จริงของคุณจะขึ้นอยู่กับขนาด Input, แผน และระดับบริการร่วมกัน สำหรับตัวเลขราคาต่อโทเคนปัจจุบัน โปรดตรวจสอบ หน้า pricing และ model ของ MiniMax และ เอกสาร API เนื่องจากอัตราที่ประกาศอาจมีการเปลี่ยนแปลง
คำถามที่พบบ่อย (FAQ)
มีวิธีทดลองใช้ M3 ฟรีหรือไม่ มี คุณสามารถทดสอบโมเดลได้โดยไม่ต้องผูกมัดกับแผนใดๆ และมีหลายวิธีที่ไม่มีค่าใช้จ่าย เราได้รวบรวมไว้ใน วิธีใช้ MiniMax M3 ฟรี
มี SDK ใดบ้างที่ใช้งานได้กับ API นี้ มีสามตัวเลือก: Raw HTTP, Anthropic SDK และ OpenAI SDK MiniMax แนะนำ Anthropic SDK แต่ทั้งสามวิธีก็เรียกใช้ Endpoint https://api.minimax.io/v1/chat/completions เดียวกัน สำหรับไคลเอนต์ OpenAI และ Anthropic คุณเพียงแค่เปลี่ยน base_url ให้ชี้ไปที่ MiniMax
ฉันจะ Streaming Response ได้อย่างไร เพิ่ม "stream": true ไปยัง Request Body ของคุณ API จะส่ง Server-sent Events กลับมา และ SDK ทั้งสองจะเปิดเผย Iterator ที่คุณสามารถวนซ้ำเพื่ออ่านส่วนข้อมูลที่เข้ามา ทดสอบ Stream ใน Apidog ก่อน เพื่อให้คุณเห็นรูปแบบ Event ก่อนที่จะ Parse
Rate Limit คือเท่าไร ขีดจำกัดขึ้นอยู่กับระดับบัญชีของคุณ และว่าคุณใช้บริการแบบ standard หรือ priority หากคุณเจอ Error 429 ให้หยุดพักแล้วลองใหม่ หรือย้ายทราฟฟิกที่อ่อนไหวต่อ Latency ไปยังระดับ Priority ตัวเลขปัจจุบันอยู่ใน Dashboard บัญชีของคุณและเอกสาร API
เกณฑ์ 512K มีผลต่อค่าใช้จ่ายของฉันอย่างไร การเรียกใช้ที่มี Input 512K โทเคน หรือน้อยกว่า จะถูกเรียกเก็บเงินในอัตรามาตรฐาน หาก Input โทเคนเกิน 512K จะใช้อัตรา Long-Context ที่สูงขึ้น ตัด Prompt ของคุณให้เหลือเฉพาะโทเคนที่โมเดลต้องการจริงๆ โดยเฉพาะอย่างยิ่งใน Agent Loops ที่ค่าใช้จ่ายจะเพิ่มขึ้นจากการเรียกใช้หลายครั้ง
ฉันสามารถ Self-host โมเดลแทนการเรียกใช้ API ได้หรือไม่ Hosted API เป็นเส้นทางที่คู่มือนี้ครอบคลุม และเป็นวิธีที่เร็วที่สุดในการเริ่มต้น การ Self-host ขึ้นอยู่กับสิ่งที่ MiniMax เผยแพร่สำหรับ M3 ณ เวลาใดเวลาหนึ่ง ดังนั้นโปรดตรวจสอบ หน้าโมเดล สำหรับสถานะน้ำหนักและใบอนุญาตปัจจุบัน
สรุป
ตอนนี้คุณมีทุกอย่างพร้อมที่จะเรียกใช้ MiniMax M3 แล้ว: API Key ที่จัดเก็บเป็น Environment Variable, การเรียกใช้ Curl, Python และ Node ที่ทำงานได้, ตัวสลับการให้เหตุผล (Thinking Toggle), เกณฑ์การเรียกเก็บเงิน 512K และการเชื่อมต่อ Tool-Calling วิธีที่เร็วที่สุดในการทำให้เข้าใจคือการลองเรียกใช้จริงด้วยตนเองหนึ่งครั้ง ใส่ Endpoint ลงใน Apidog, เก็บ Bearer Token ของคุณเป็น Environment Variable, ส่ง Prompt สำหรับการ Refactor, และอ่าน Response เมื่อคุณเห็นรูปแบบดิบแล้ว การเชื่อมต่อเข้ากับโค้ดของคุณจะใช้เวลาเพียงไม่กี่นาที