Thanawat Wongchai

Posted on May 21 • Originally published at apidog.com

วิธีใช้ Qwen 3.7 API

ทีม Qwen ของ Alibaba เปิดตัว Qwen3.7-Max-Preview ช่วงกลางเดือนพฤษภาคม 2026 และคำถามหลักของนักพัฒนาคือ: จะเรียกใช้จากโค้ดได้อย่างไร? โมเดลนี้เป็นระบบการให้เหตุผลระดับเรือธง มี context window ขนาด 1M โทเค็น และแสดง chain-of-thought traces ได้ชัดเจน จึงเหมาะกับ backend ของ agent, การวิเคราะห์เอกสารขนาดยาว และการสร้างโค้ด แต่คำว่า “preview” หมายความว่าการเข้าถึงยังจำกัด API อาจเปลี่ยนแปลง และรายละเอียดที่ต้องใช้จริงยังกระจายอยู่ใน release notes กับเอกสารแพลตฟอร์ม

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

สรุป (TL;DR)

Qwen3.7-Max-Preview คือโมเดลการให้เหตุผลระดับเรือธงของ Alibaba เปิดตัวแบบพรีวิวเมื่อวันที่ 14 พฤษภาคม 2026 พร้อม context window ขนาด 1M โทเค็น ช่วงพรีวิว วิธีที่เชื่อถือได้ที่สุดในการทดลองคือ Qwen Chat (chat.qwen.ai) ส่วนการเรียกใช้งานจริงผ่าน API ใช้ Alibaba Cloud Model Studio หรือ DashScope ผ่าน endpoint ที่เข้ากันได้กับ OpenAI โดยตั้งค่า base URL, ส่ง API key เป็น Bearer token และเรียก /chat/completions

เนื่องจากรุ่น 3.7 ยังเป็น preview ให้ตรวจสอบ model ID และ endpoint ล่าสุดจากเอกสารทางการก่อนใช้งานจริง และใช้ Apidog เพื่อทดสอบ/จำลอง endpoint ระหว่างที่ availability ยังไม่เสถียร

วิธีเข้าถึง Qwen 3.7 ตอนนี้

Qwen เปิดให้ใช้โมเดลผ่านหลายช่องทาง และแต่ละช่องทางไม่ได้พร้อมใช้งานพร้อมกันทั้งหมด ณ สิ้นเดือนพฤษภาคม 2026 สถานะโดยสรุปคือ:

1. Qwen Chat

Qwen Chat (chat.qwen.ai) เป็นวิธีที่เร็วที่สุดในการลอง Qwen3.7-Max-Preview

ขั้นตอน:

เข้า chat.qwen.ai
ลงชื่อเข้าใช้ด้วยบัญชี Qwen
เลือกโมเดล qwen3.7-max-preview
เปิด Thinking Mode หากต้องการดูร่องรอยการคิด

ข้อจำกัดคือมี rate limit ช่วงพรีวิว และเป็น browser product ไม่ใช่ API จึงเหมาะกับการประเมิน prompt และคุณภาพคำตอบ มากกว่าการ integrate เข้าระบบจริง

2. Alibaba Cloud Model Studio (DashScope)

Alibaba Cloud Model Studio (DashScope) คือช่องทาง API สำหรับโมเดล Qwen โดยให้ endpoint ที่เข้ากันได้กับ OpenAI ดังนั้นถ้าโค้ดของคุณใช้ OpenAI SDK อยู่แล้ว คุณสามารถเปลี่ยนแค่ base_url และ API key เพื่อเรียก Qwen ได้

โมเดลรุ่นก่อน เช่น qwen3.6-max-preview และตระกูล qwen-max มีให้ใช้งานผ่านช่องทางนี้แล้ว ส่วน Qwen3.7-Max-Preview อาจยังไม่มี API สาธารณะในเวลาที่คุณอ่านบทความนี้ เพราะ Qwen มักเปิด API หลังจากเปิด chat preview ไปแล้วระยะหนึ่ง

3. รูปแบบ OpenAI-compatible

โมเดล Qwen ล่าสุดบน Model Studio ใช้รูปแบบเดียวกัน:

ใช้ OpenAI-compatible client
ตั้ง base_url เป็น DashScope endpoint
ส่ง API key ผ่าน Authorization: Bearer
เรียก /chat/completions

เมื่อ model ID ของ Qwen 3.7 พร้อมใช้งาน คุณมักต้องเปลี่ยนแค่ค่าของ model

เนื่องจาก model ID และ endpoint อาจเปลี่ยนระหว่าง preview ให้ยึด เอกสารทางการของ Qwen และ รายการโมเดลของ Model Studio เป็นแหล่งข้อมูลหลัก

หากต้องการทดลองแบบฟรีก่อนใช้ API ดูคู่มือ ใช้งาน Qwen 3.7 ฟรี

วิธีการเข้าถึงโดยสรุป

วิธี	การเข้าถึง API	ค่าใช้จ่าย	เหมาะที่สุดสำหรับ
Qwen Chat (chat.qwen.ai)	ไม่	ฟรี, จำกัดอัตรา	การประเมินเร็ว, ทดสอบ prompt
Alibaba Cloud Model Studio (DashScope)	ใช่, OpenAI-compatible	จ่ายตามโทเค็น	การ integrate สำหรับ production
Qwen บน Hugging Face	น้ำหนักโมเดล เมื่อเปิดตัว	ฟรี หาก host เอง	โมเดล open-weight ไม่ใช่ Max preview
เกตเวย์ของบุคคลที่สาม	แตกต่างกันไป	แตกต่างกันไป	การ route หลายโมเดล

ข้อควรจำ: โมเดล Qwen แบบ open-weight อาจมีบน Hugging Face แต่รุ่น Max-Preview เป็น proprietary ดังนั้นอย่าคาดหวังว่าจะมีน้ำหนักโมเดล qwen3.7-max-preview ให้ดาวน์โหลด

การรับ API Key ของ Qwen 3.7

การเข้าถึง API ใช้บัญชี Alibaba Cloud

ขั้นตอน:

สร้างบัญชี Alibaba Cloud
เปิดคอนโซล Model Studio ที่ modelstudio.console.alibabacloud.com
เปิดใช้งาน Model Studio สำหรับบัญชีและ region ของคุณ
ไปที่ส่วน API keys
สร้าง key ใหม่
คัดลอก key และเก็บเหมือนรหัสผ่าน

API key ถูกจำกัดตาม region เช่น key ของ Singapore endpoint อาจใช้ยืนยันตัวตนกับ Beijing endpoint ไม่ได้

เลือก region ให้ถูกต้อง เพราะจะกำหนด base URL:

ภูมิภาค	Base URL
สิงคโปร์	`https://dashscope-intl.aliyuncs.com/compatible-mode/v1`
สหรัฐอเมริกา (เวอร์จิเนีย)	`https://dashscope-us.aliyuncs.com/compatible-mode/v1`
ปักกิ่ง (จีน)	`https://dashscope.aliyuncs.com/compatible-mode/v1`

อย่า hard-code key ใน source code ให้ใช้ environment variable แทน:

# macOS / Linux
export DASHSCOPE_API_KEY="sk-your-key-here"

# Windows PowerShell
setx DASHSCOPE_API_KEY "sk-your-key-here"

จากนั้นให้โค้ดอ่าน DASHSCOPE_API_KEY ตอน runtime วิธีนี้ช่วยลดความเสี่ยง key รั่วใน repository และช่วย rotate key ได้โดยไม่ต้องแก้โค้ด หลักการเดียวกันนี้ใช้ได้กับ API โมเดลอื่น เช่นในคู่มือ Gemini 3.5 API

คำขอแรกของคุณ: Python, curl และ JavaScript

endpoint ของ Qwen บน Model Studio เข้ากันได้กับ OpenAI คุณจึงเลือกได้สองวิธี:

ใช้ OpenAI SDK แล้วเปลี่ยน base_url
เรียก HTTP โดยตรง

หมายเหตุ: qwen3.7-max-preview คือ model ID ที่ใช้ใน Qwen Chat สำหรับ preview แต่ API อาจใช้ชื่อที่ต่างออกไปในช่วงพรีวิว ให้ตรวจสอบ model ID ล่าสุดใน Model Studio ก่อนใส่ในฟิลด์ model

Python พร้อม OpenAI SDK

ติดตั้ง SDK:

pip install openai

ส่งคำขอ:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    # ใช้ base URL ตาม region ของบัญชีคุณ
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

response = client.chat.completions.create(
    # ตรวจสอบ model ID ล่าสุดใน Model Studio ก่อนใช้งานจริง
    model="qwen3.7-max-preview",
    messages=[
        {"role": "system", "content": "คุณคือผู้ช่วยเขียนโค้ดที่แม่นยำ"},
        {"role": "user", "content": "เขียนฟังก์ชัน Python ที่กลับด้าน linked list"},
    ],
)

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

โครงสร้าง messages ใช้ role มาตรฐาน:

system กำหนดพฤติกรรมของโมเดล
user คือคำถามหรือคำสั่งจากผู้ใช้

ผลลัพธ์อยู่ที่:

response.choices[0].message.content

curl

ใช้ curl เพื่อทดสอบ key และ endpoint ก่อนเขียนแอป:

curl 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions' \
  --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "qwen3.7-max-preview",
    "messages": [
      {"role": "user", "content": "อธิบาย idempotency ใน REST APIs ในสองประโยค"}
    ]
  }'

ถ้า key, region และ model ID ถูกต้อง คุณจะได้ JSON response กลับมา หากผิดพลาด ให้ดู status code และ error body เพื่อแก้ปัญหา

JavaScript / Node.js

ติดตั้ง SDK:

npm install openai

เรียก API:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
});

const response = await client.chat.completions.create({
  model: "qwen3.7-max-preview",
  messages: [
    { role: "user", content: "ระบุข้อดีข้อเสียสามประการของ GraphQL เทียบกับ REST" },
  ],
});

console.log(response.choices[0].message.content);

สามภาษา รูปแบบคำขอเดียว นี่คือข้อดีของ OpenAI-compatible API

การตอบกลับแบบสตรีมมิ่ง

สำหรับ UI ที่ผู้ใช้มองเห็น ไม่ควรรอให้คำตอบทั้งหมดเสร็จก่อนแสดงผล การ streaming จะส่ง token ออกมาระหว่างที่โมเดลกำลังสร้างคำตอบ

ตั้งค่า stream=True แล้ววนอ่าน chunk

Python streaming

stream = client.chat.completions.create(
    model="qwen3.7-max-preview",
    messages=[
        {"role": "user", "content": "สรุปทฤษฎี CAP"},
    ],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Node.js streaming

const stream = await client.chat.completions.create({
  model: "qwen3.7-max-preview",
  messages: [{ role: "user", content: "สรุปทฤษฎี CAP" }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || "");
}

Streaming สำคัญเป็นพิเศษกับโมเดล reasoning เพราะโมเดลอาจใช้เวลาคิดก่อนให้คำตอบสุดท้าย หากไม่มี streaming ผู้ใช้จะเห็นหน้าจอว่างนานเกินไป คุณสามารถใช้ streaming เพื่อแสดง typing indicator, partial answer หรือ reasoning trace ตามการออกแบบของแอป

พารามิเตอร์การให้เหตุผลและการคิด

Qwen3.7-Max-Preview เป็นโมเดลการให้เหตุผล และสามารถสร้างกระบวนการคิดในบล็อก <think> ก่อนคำตอบสุดท้ายได้ ร่องรอยนี้มีประโยชน์กับงานหลายขั้นตอน เช่น คณิตศาสตร์, debugging, planning และ analysis

สำหรับโมเดล Qwen ล่าสุดที่ให้บริการผ่าน DashScope พฤติกรรมการคิดควบคุมด้วย flag เช่น enable_thinking แต่ชื่อพารามิเตอร์และกลไกอาจเปลี่ยนตามเวอร์ชัน ให้ตรวจสอบเอกสาร API ล่าสุดก่อนใช้ production

ตัวอย่างเชิงแนวคิด:

response = client.chat.completions.create(
    model="qwen3.7-max-preview",
    messages=[
        {
            "role": "user",
            "content": (
                "รถไฟขบวนหนึ่งออกเวลาบ่าย 2 โมงด้วยความเร็วเฉลี่ย 60 ไมล์ต่อชั่วโมง "
                "รถไฟขบวนที่สองออกเวลาบ่าย 3 โมงด้วยความเร็ว 75 ไมล์ต่อชั่วโมง บนเส้นทางเดียวกัน "
                "รถไฟขบวนที่สองจะตามทันขบวนแรกเมื่อใด?"
            ),
        },
    ],
    # ตรวจสอบชื่อ parameter ล่าสุดจากเอกสาร Model Studio ก่อนใช้งานจริง
    extra_body={"enable_thinking": True},
)

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

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

การคิดใช้ token และเวลา

reasoning trace คือข้อความที่โมเดลสร้าง จึงเพิ่ม latency และ token cost
เปิดใช้กับงานซับซ้อน

เช่น math, code reasoning, planning, multi-step analysis
ปิดใช้กับงานง่าย

เช่น classification, formatting, extraction หรือ lookup ทั่วไป
ตัดสินใจว่าจะโชว์ <think> หรือไม่

บางแอปแสดง reasoning trace เพื่อความโปร่งใส บางแอปตัดออกแล้วแสดงเฉพาะ final answer

ถ้าคุณกำลังเทียบคุณภาพและต้นทุนกับโมเดลอื่น ดูบทความ Qwen 3.7 vs GPT-5.5 vs Opus 4.7 และถ้าใช้ agent loop ที่ใช้ token สูง เทคนิคในบทความ ลดต้นทุนโทเค็นของเอเจนต์ สามารถนำไปใช้ได้โดยตรง

การจัดการข้อผิดพลาดและ rate limit

คำขอ API อาจล้มเหลวด้วยเหตุผลที่คาดเดาได้ จัดการ error ให้ชัดเจนเพื่อให้แอปไม่พังแบบเงียบ ๆ

HTTP status	ความหมาย	สิ่งที่ต้องทำ
400	request ไม่ถูกต้อง เช่น JSON ผิด, parameter ผิด	ตรวจ request body, model ID และ field name
401	API key ผิดหรือไม่ได้ส่ง key	ตรวจ key และ region ของ endpoint
403	ไม่มีสิทธิ์เข้าถึงโมเดล	preview อาจจำกัดสิทธิ์ ตรวจว่าบัญชีเปิดใช้งานแล้ว
404	ไม่พบโมเดล	model ID ผิด หรือยังไม่มีใน region นั้น
429	เกิน rate limit หรือ quota	backoff แล้ว retry, ตรวจ QPS และ quota
500 / 503	server error	retry ด้วย exponential backoff

โมเดล preview มักเจอ 403 และ 404 มากกว่าโมเดล stable เพราะสิทธิ์เข้าถึงและ model ID ยังเปลี่ยนได้ หากเจอ error เหล่านี้ ปัญหามักอยู่ที่ access หรือ model string ไม่ใช่ logic ของโค้ด

ตัวอย่าง retry สำหรับ Python:

import os
import time
from openai import OpenAI, RateLimitError, APIStatusError

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

def ask_qwen(prompt, max_retries=4):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="qwen3.7-max-preview",
                messages=[{"role": "user", "content": prompt}],
            )
            return response.choices[0].message.content

        except RateLimitError:
            wait = 2 ** attempt  # 1s, 2s, 4s, 8s
            print(f"เกินขีดจำกัดอัตรา กำลังลองใหม่ใน {wait} วินาที...")
            time.sleep(wait)

        except APIStatusError as e:
            # 400/401/403/404 มัก retry แล้วไม่หาย
            print(f"ข้อผิดพลาด API {e.status_code}: {e.message}")
            raise

    raise RuntimeError("ล้มเหลวหลังจากลองใหม่หลายครั้ง")

แนวทางคือ:

retry สำหรับ 429 และ 5xx
fail fast สำหรับ 4xx ที่เกิดจาก request, key หรือ permission
ใช้ exponential backoff เพื่อลดการยิงซ้ำเมื่อ API ยังไม่พร้อม

การทดสอบและการจำลอง Qwen API ด้วย Apidog

API แบบ preview ทำให้ development ยากขึ้น เพราะ:

access ถูกจำกัด
model ID เปลี่ยนได้
rate limit เข้มงวด
endpoint จริงอาจยังไม่พร้อมสำหรับบัญชีของคุณ

แทนที่จะรันทั้งแอปแล้วไล่ดู log คุณควรแยก API request ออกมาทดสอบ บันทึก และรันซ้ำได้ เครื่องมืออย่าง Apidog ช่วยใน workflow นี้

Workflow แนะนำ

สร้าง request สำหรับ /chat/completions
ตั้ง environment variable เช่น DASHSCOPE_API_KEY
ตั้ง base URL ตาม region
ใส่ request body พร้อม model และ messages
ส่ง request เพื่อดู response จริง
บันทึก case ที่ใช้ซ้ำ
สร้าง mock response สำหรับ frontend หรือ agent runtime
เมื่อ API จริงพร้อม ให้เปลี่ยนจาก mock base URL ไปเป็น DashScope base URL

จำลอง endpoint ระหว่างพัฒนา

Mock server ของ Apidog สามารถคืน response ที่สมจริงจาก API schema ได้โดยไม่ต้องใช้ key และไม่ติด rate limit ทำให้ frontend หรือ agent ของคุณพัฒนาต่อได้ แม้ API preview จริงยังจำกัดหรือยังไม่เปิดให้บัญชีของคุณ

เมื่อ API จริงพร้อมใช้งาน ให้เปลี่ยน base URL จาก mock ไปเป็น DashScope โดยไม่ต้องแก้ application logic

อ่านเพิ่มเติมเกี่ยวกับ workflow แบบ schema-first ได้ที่ การแนะนำโหมด spec-first

รูปแบบนี้ใช้ได้กับ API โมเดลอื่นเช่นกัน ไม่ว่าจะเป็น Qwen, Gemini หรือ ERNIE 5.1 API โมเดล preview ยิ่งทำให้ mock endpoint มีประโยชน์ เพราะ endpoint จริงเป็นส่วนที่ไม่เสถียรที่สุดใน stack

สรุป

การเรียกใช้ Qwen 3.7 ไม่ซับซ้อนเมื่อเข้าใจ path หลัก:

ทดลองโมเดลผ่าน Qwen Chat
ใช้ Model Studio / DashScope สำหรับ API
ตั้ง OpenAI-compatible base_url
เก็บ API key ใน environment variable
ตรวจ model ID ล่าสุดก่อนใช้งานจริง
ใช้ streaming กับงานที่ผู้ใช้ต้องรอนาน
จัดการ 429, 403, 404 และ 5xx ให้ถูกต้อง
ใช้ mock API ระหว่างที่ preview ยังไม่เสถียร

เลิกเดาว่า Qwen คืนค่าอะไร แล้วเริ่มทดสอบ request จริง ดาวน์โหลด Apidog เพื่อออกแบบ Qwen endpoint, ส่ง test request, บันทึก scenario ที่ใช้ซ้ำได้ และจำลอง API ระหว่างพัฒนา

DEV Community