Thanawat Wongchai

Posted on Jun 1 • Originally published at apidog.com

วิธีใช้ MiniMax M3 API

MiniMax M3 เป็นโมเดลการให้เหตุผลและการเขียนโค้ดที่รองรับ Context Window สูงสุด 1,000,000 โทเคน เหมาะกับงานที่ต้องป้อนข้อมูลจำนวนมาก เช่น Repository ทั้งชุด, Log หลายวัน, หรือเอกสารออกแบบขนาดยาว แล้วให้โมเดลวิเคราะห์ในการเรียกใช้ครั้งเดียว หากต้องการเข้าใจภาพรวมของโมเดลก่อนเริ่มใช้งาน อ่าน MiniMax M3 คืออะไร

ลองใช้ Apidog วันนี้

คู่มือนี้เน้นการใช้งานจริง: สร้าง API Key, ส่ง Request แรกด้วย Curl, Python และ Node.js, เปิด/ปิด Reasoning, ใช้งาน Context ขนาดใหญ่ และทดสอบทุกขั้นตอนใน Apidog เพื่อดู Request/Response ดิบก่อนนำไปฝังในแอป หากต้องการทำตาม ให้ ดาวน์โหลด Apidog

เอกสารอ้างอิงอย่างเป็นทางการ: เอกสาร API ของ MiniMax

สิ่งที่คุณต้องมี

บัญชี MiniMax ที่ platform.minimax.io
API Key
วิธีการชำระเงิน: Pay-as-you-go credit หรือแผน Token แบบ Subscription
สำหรับตัวอย่าง SDK:
- Python 3.8+
- Node.js 18+

สำหรับ Curl ไม่ต้องติดตั้งอะไรเพิ่มเติมนอกจาก curl

ขั้นตอนที่ 1: สร้าง API Key

เข้าสู่ระบบที่ platform.minimax.io แล้วไปที่ส่วน API Keys เพื่อสร้าง Key ใหม่

MiniMax มี Key สองประเภท:

ประเภท Key	ใช้กับ	หมายเหตุ
API Key ทั่วไป	Pay-as-you-go balance	หักจากยอดคงเหลือ
Subscription Key	Plus, Max, Ultra plan	ใช้เครดิตโทเคนจากแผน หากเครดิตหมด การเรียกใช้จะหยุดจนกว่าจะต่ออายุหรือเปลี่ยน Key

หลังจากสร้าง Key แล้ว ให้คัดลอกและเก็บไว้ทันที เพราะคุณอาจไม่เห็น Key นี้อีก

อย่าใส่ API Key ตรง ๆ ใน Source Code ให้ใช้ Environment Variable แทน:

export MINIMAX_API_KEY="your-key-here"

วิธีนี้ช่วยลดความเสี่ยงที่ Key จะหลุดเข้า Git History, Log หรือไฟล์ที่แชร์กับทีม หากคุณทำงานกับ API Key ใน Editor อ่านเพิ่มเติมได้ที่ ความปลอดภัยของ API Key ในส่วนขยาย VS Code

ขั้นตอนที่ 2: ส่ง Request แรก

MiniMax M3 ใช้ Endpoint นี้:

POST https://api.minimax.io/v1/chat/completions

ค่าหลักที่ต้องใช้:

Base URL: https://api.minimax.io/v1
Model ID: MiniMax-M3
Auth: Authorization: Bearer $MINIMAX_API_KEY

เรียกด้วย Curl

ตัวอย่างสั้นที่สุดสำหรับทดสอบว่า Key และ Endpoint ใช้งานได้:

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."
      }
    ]
  }'

ถ้า API Key ถูกต้อง คุณจะได้ Response JSON ที่มีคำตอบของโมเดลอยู่ใน choices[0].message.content

ขั้นตอนที่ 3: เรียก MiniMax M3 ด้วย OpenAI SDK

MiniMax รองรับรูปแบบ API ที่ใช้งานกับ OpenAI SDK ได้ จุดที่ต้องเปลี่ยนคือ base_url

Python

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.minimax.io/v1",
    api_key=os.environ["MINIMAX_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.js

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);

MiniMax แนะนำ Anthropic SDK ด้วยเช่นกัน แต่ Raw HTTP, OpenAI SDK และ Anthropic SDK สามารถเรียก Endpoint เดียวกันได้ หากคุณเคยใช้ Qwen 3.7 API รูปแบบนี้จะคุ้นเคย เพราะโมเดลสมัยใหม่จำนวนมากรองรับ API Surface ที่คล้าย OpenAI

เอกสาร SDK:

ขั้นตอนที่ 4: ทดสอบ Request ใน Apidog

ก่อนฝัง API ลงในแอปจริง ควรทดสอบ Request และดู Response ดิบก่อนใน Apidog

ทำตามขั้นตอนนี้:

สร้าง HTTP Request ใหม่
ตั้ง Method เป็น POST
ใส่ URL:

https://api.minimax.io/v1/chat/completions

เปิด Environments แล้วเพิ่มตัวแปร:

MINIMAX_API_KEY = your-key-here

เพิ่ม Header:

Authorization: Bearer {{MINIMAX_API_KEY}}
Content-Type: application/json

ตั้ง Body เป็น Raw JSON:

{
  "model": "MiniMax-M3",
  "messages": [
    {
      "role": "user",
      "content": "Refactor this function to be async."
    }
  ]
}

กด Send แล้วตรวจสอบ Response

[ภาพหน้าจอ: คำขอและคำตอบของ MiniMax-M3 ใน Apidog]

การเก็บ Token เป็น Environment Variable ช่วยให้แชร์ Request กับทีมได้โดยไม่เปิดเผยข้อมูลลับ และสามารถสลับระหว่าง Pay-as-you-go Key กับ Subscription Key ได้ด้วยการเปลี่ยนค่าตัวแปรเดียว

หากเปิด Streaming ในภายหลัง Apidog จะแสดง Server-sent Events ที่ส่งกลับมา ทำให้ตรวจรูปแบบ Stream ได้ก่อนเขียน Parser ในโค้ดจริง

ขั้นตอนที่ 5: เปิดหรือปิด Reasoning

MiniMax M3 เป็นโมเดล Reasoning โดยค่าเริ่มต้นจะส่งกลับเฉพาะคำตอบสุดท้าย แต่คุณสามารถขอให้แยกข้อมูล Reasoning ออกมาได้ด้วย reasoning_split

Python ตัวอย่าง Reasoning

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.minimax.io/v1",
    api_key=os.environ["MINIMAX_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"])  # reasoning
print(response.choices[0].message.content)                       # final answer

เมื่อเปิด reasoning_split:

Reasoning อยู่ที่:

response.choices[0].message.reasoning_details[0]["text"]

คำตอบสุดท้ายอยู่ที่:

response.choices[0].message.content

แนวทางใช้งาน:

กรณี	ควรเปิด Reasoning หรือไม่
Refactor หลายขั้นตอน	เปิด
วิเคราะห์ Bug ซับซ้อน	เปิด
ตรวจสอบเหตุผลของโมเดล	เปิด
งานง่าย เช่น Rewrite ข้อความสั้น	ปิด
งานที่ Sensitive ต่อ Latency	ปิด
ต้องการลดค่าใช้จ่าย Token	ปิด

แยก Reasoning ออกจากคำตอบใน UI ของคุณ เช่น แสดงเฉพาะ Final Answer ให้ผู้ใช้ แต่เก็บ Reasoning ไว้ใน Log หรือระบบ Review

ขั้นตอนที่ 6: ใช้ Context Window ขนาด 1M Token

จุดเด่นของ M3 คือ Context Window ขนาดใหญ่ คุณสามารถส่ง Log หรือไฟล์จำนวนมากเข้าไปใน Prompt เดียวได้

ตัวอย่างวิเคราะห์ Production Log:

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.minimax.io/v1",
    api_key=os.environ["MINIMAX_API_KEY"],
)

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": (
                "Find the root cause of the 502 spike at 14:20 UTC.\n\n"
                f"{log_text}"
            ),
        }
    ],
)

print(response.choices[0].message.content)

ข้อควรระวังด้านค่าใช้จ่าย:

Input Token ≤ 512K ใช้อัตรามาตรฐาน
Input Token > 512K ใช้อัตรา Long-Context ที่สูงกว่า

ดังนั้น Prompt 400K token กับ 600K token ไม่ได้ต่างกันแบบ Linear เสมอ เพราะ 600K ข้าม Threshold 512K แล้ว

แนวทางปฏิบัติ:

อย่าส่ง Context ขนาดใหญ่โดยไม่จำเป็น
ตัดเฉพาะไฟล์หรือ Log ที่เกี่ยวข้อง
ใน Agent Loop ให้ Trim Context ทุกครั้งก่อนเรียก API
สรุปข้อมูลระหว่างรอบ แทนการส่ง History ทั้งหมดซ้ำ

อ่านเพิ่มเติม: วิธีลดค่าใช้จ่ายโทเคนของ Agent

ขั้นตอนที่ 7: ใช้ Tool Calling

MiniMax M3 รองรับ Tool Calling จึงสามารถใช้สร้าง Agent ที่เรียกฟังก์ชันภายนอก เช่น Run test, Query database หรือเรียก Internal API ได้

ตัวอย่างประกาศ Tool:

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,
)

เมื่อโมเดลต้องการเรียก Tool Response จะมี tool_calls กลับมา จากนั้นโค้ดของคุณต้อง:

อ่าน tool_calls
Map ชื่อ Tool ไปยังฟังก์ชันจริงในระบบ
Execute ฟังก์ชันนั้น
ส่งผลลัพธ์กลับเข้า API เป็น Message ประเภท tool
เรียก API อีกครั้งเพื่อให้โมเดลดำเนินงานต่อ

Bug ใน Agent จำนวนมากเกิดจากขั้นตอน Handshake ระหว่าง Model ↔ Tool ↔ Model อ่านแนวทางเพิ่มเติมได้ที่ การเชื่อมต่อเครื่องมือใน Workflow แบบ Agentic

ใน Apidog คุณสามารถบันทึกแต่ละ Request ของ Multi-turn Flow แยกกัน เช่น:

Initial request
Response ที่มี Tool call
Request ที่ส่ง Tool result กลับไป
Final response

วิธีนี้ช่วย Debug ได้ง่ายกว่าไล่ดู Agent Runtime ภายในอย่างเดียว

ขั้นตอนที่ 8: ใช้ Input แบบ Multimodal

M3 รองรับ Input แบบ Multimodal ดังนั้นนอกจากข้อความแล้ว ยังสามารถส่งรูปภาพร่วมกับ Prompt ได้ด้วย

รูปแบบทั่วไปคือส่ง Content เป็น Array ที่มีหลาย Part เช่น Text และ Image โดยควรอ้างอิงชื่อ Field ล่าสุดจาก เอกสาร API ของ MiniMax เพราะรูปแบบ Multimodal มักเปลี่ยนเร็วกว่า Text Endpoint

ใช้กรณีนี้เมื่อคุณต้องการให้โมเดล:

อ่าน Screenshot
วิเคราะห์ Diagram
ตรวจ UI Bug จากภาพ
อธิบายข้อมูลจากรูปภาพประกอบ Prompt

ราคาและระดับบริการ

ค่าใช้จ่ายขึ้นอยู่กับ 2 ส่วนหลัก:

แผน Token หรือ Pay-as-you-go
Service Tier

แผน Token

MiniMax มีระดับ Subscription เช่น:

Plus: $20
Max: $50
Ultra: $120

แต่ละแผนให้เครดิตโทเคนจำนวนต่างกัน และ Subscription Key จะหักเครดิตจากแผนนั้น ส่วน Pay-as-you-go API Key จะหักจากยอดคงเหลือแทน

Service Tier

มีสองระดับ:

Tier	เหมาะกับ
`standard`	Workload ทั่วไป
`priority`	งานที่ Sensitive ต่อ Latency หรือมี SLA

เมื่อนำมารวมกับ Threshold 512K Token ค่าใช้จ่ายจริงจะขึ้นอยู่กับ:

จำนวน Input Token
จำนวน Output Token
ใช้อัตรา Standard หรือ Long-Context
ใช้ Pay-as-you-go หรือ Subscription
ใช้ Service Tier แบบ standard หรือ priority

ตรวจราคาล่าสุดได้ที่ หน้า pricing และ model ของ MiniMax และ เอกสาร API

FAQ

มีวิธีทดลองใช้ M3 ฟรีหรือไม่?

มี MiniMax มีหลายวิธีให้ทดลองใช้โมเดลโดยไม่ต้องเริ่มจากแผนเสียเงิน อ่านรายละเอียดได้ที่ วิธีใช้ MiniMax M3 ฟรี

ใช้ SDK อะไรได้บ้าง?

ใช้ได้ 3 วิธีหลัก:

Raw HTTP
OpenAI SDK
Anthropic SDK

MiniMax แนะนำ Anthropic SDK แต่ OpenAI SDK ก็ใช้งานได้โดยเปลี่ยน base_url เป็น:

https://api.minimax.io/v1

Streaming Response ทำอย่างไร?

เพิ่ม stream: true ใน Request Body:

{
  "model": "MiniMax-M3",
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Explain this error log."
    }
  ]
}

API จะส่ง Server-sent Events กลับมา SDK จะเปิด Iterator ให้คุณอ่าน Chunk ที่เข้ามาได้ ควรทดสอบ Stream ใน Apidog ก่อนเขียน Parser จริง

Rate Limit คือเท่าไร?

Rate Limit ขึ้นอยู่กับระดับบัญชีและ Service Tier (standard หรือ priority) หากเจอ Error 429 ให้ใช้ Backoff แล้ว Retry หรือย้าย Traffic ที่ต้องการ Latency ต่ำไปยัง priority

ตัวเลขล่าสุดควรดูจาก Dashboard บัญชีและเอกสาร API

Threshold 512K ส่งผลต่อค่าใช้จ่ายอย่างไร?

ถ้า Input Token ไม่เกิน 512K จะใช้อัตรามาตรฐาน หากเกิน 512K จะใช้อัตรา Long-Context ที่สูงกว่า ควรตัด Prompt ให้เหลือเฉพาะข้อมูลที่จำเป็น โดยเฉพาะใน Agent Loop ที่มีการเรียก API หลายรอบ

Self-host MiniMax M3 ได้หรือไม่?

คู่มือนี้ครอบคลุม Hosted API ซึ่งเป็นวิธีเริ่มต้นที่เร็วที่สุด ส่วนการ Self-host ขึ้นอยู่กับสิ่งที่ MiniMax เปิดเผยสำหรับ M3 ณ เวลานั้น ตรวจสอบสถานะล่าสุดได้ที่ หน้าโมเดล MiniMax M3

สรุป

ตอนนี้คุณมี Workflow พื้นฐานสำหรับใช้งาน MiniMax M3 แล้ว:

สร้าง API Key
เก็บ Key เป็น Environment Variable
เรียก API ด้วย Curl
ใช้ OpenAI SDK ใน Python และ Node.js
ทดสอบ Request/Response ใน Apidog
เปิด Reasoning เมื่อจำเป็น
ใช้ Context ขนาดใหญ่โดยระวัง Threshold 512K
เริ่มต่อ Tool Calling สำหรับ Agent

วิธีเริ่มที่เร็วที่สุดคือใส่ Endpoint ลงใน Apidog, ตั้ง Authorization ด้วย Environment Variable, ส่ง Prompt สั้น ๆ และอ่าน Response ดิบก่อน เมื่อเข้าใจ Schema แล้ว การนำไปเชื่อมกับโค้ดจริงจะตรงไปตรงมามากขึ้น

DEV Community