คู่มือ Polymarket API: CLOB, REST และบอทเทรดดิ้ง (2026)

บทที่ 27 จาก 33

เวอร์ชันสั้น

Polymarket เปิดให้ใช้ 3 API สาธารณะ: CLOB (การเทรด), Gamma (การค้นพบตลาด), และ Data (การวิเคราะห์) SDK Python อย่างเป็นทางการคือ py-clob-client 0.34.6 การยืนยันตัวตนใช้ API key + ECDSA signature โดยลงนามคำสั่งซื้อขายผ่าน EIP-712 ด้วยกระเป๋า proxy บน Polygon ข้อจำกัดอัตราการใช้งานจำกัดคุณไว้ที่ประมาณ 60 คำสั่ง/นาที ต่อคีย์ จุดสะดุดที่ใหญ่ที่สุดสำหรับนักพัฒนาใหม่คือปัญหาการแมป condition_id → token_id ระหว่าง Gamma กับ CLOB - แก้ตรงนั้นให้ได้ก่อน แล้วอย่างอื่นจะลงตัวเอง โดยประมาณ $40M/เดือน ในรางวัลสภาพคล่องและสเปรดที่บอทเก็บเกี่ยวได้บน Polymarket แทบทั้งหมดเป็นฝีมือของผู้ใช้ API

บริการแยกกัน 3 ส่วน: CLOB (ยืนยันตัวตน 9,000/10 วินาที) สำหรับการเทรด, Gamma (สาธารณะ 4,000/10 วินาที) สำหรับการค้นพบ, Data (สาธารณะ 1,000/10 วินาที) สำหรับการวิเคราะห์เชิงประวัติ

ส่วนที่ 1: API ทั้งสาม

Polymarket แยกหน้าที่อย่างชัดเจนออกเป็นบริการที่แตกต่างกันสามตัว การใช้ API ที่เหมาะสมสำหรับแต่ละงานจะช่วยให้บอตของคุณทำงานได้เร็ว เรียบง่าย และอยู่ภายในขีดจำกัดอัตราการเรียกใช้งาน

ลูปของบอตทั่วไปจะใช้ Gamma เพื่อค้นหาตลาด ใช้ CLOB เพื่อดึงสมุดคำสั่งซื้อขายและวางการเทรด และใช้ Data เพื่อทดสอบประสิทธิภาพของกลยุทธ์ย้อนหลังแบบออฟไลน์ ให้นึกถึง Gamma ว่าเป็น "แค็ตตาล็อก" CLOB ว่าเป็น "ตลาดซื้อขาย" และ Data ว่าเป็น "คลังสินค้า"

L1 ลงนามโครงสร้าง EIP-712 "ClobAuthDomain" ด้วย chainId 137 เพื่ออนุมานข้อมูลรับรอง L2 HMAC-SHA256 ลงนามทุกคำขอถัดไปด้วยส่วนหัว POLY_SIGNATURE

ตอนที่ 2: การยืนยันตัวตนและรูปแบบกระเป๋า proxy

Polymarket จะไม่ลงนามการเทรดด้วยคีย์ส่วนตัวของกระเป๋าหลักของคุณ แต่จะใช้ กระเป๋า proxy สไตล์ Gnosis Safe: กระเป๋าหลักของคุณอนุญาตให้ proxy และ proxy จะดำเนินการเทรดทั้งหมดบน Polygon บอท API ของคุณจะสื่อสารกับ proxy นั้น

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

• API key - สร้างได้ใน Polymarket Settings → Developer
• Private key - คีย์ของ กระเป๋าเทรด ของคุณ (ไม่ใช่ seed phrase ของ MetaMask หลักของคุณ)
• Funder address - ที่อยู่กระเป๋า proxy ของคุณ (แสดงใน Settings → Wallet)
• Chain ID - 137 (Polygon mainnet)
• Signature type - 1 (POLY_PROXY มาตรฐานสำหรับผู้ใช้รายย่อย)

Signature type 1 (POLY_PROXY) สำหรับบัญชี Magic-link, type 2 (GNOSIS_SAFE) สำหรับ proxy ของกระเป๋าเบราว์เซอร์, type 0 (EOA) สำหรับคีย์โดยตรง ต้องมี Funder สำหรับ type 1 และ 2

ส่วนที่ 3: การติดตั้ง py-clob-client

Python SDK อย่างเป็นทางการเป็นวิธีที่เร็วที่สุดในการไปจากศูนย์สู่คำสั่งแรก เราจะใช้เวอร์ชัน 0.34.6 ซึ่งเป็นเวอร์ชันปัจจุบัน ณ เดือนเมษายน 2026

# สร้าง virtual environment ก่อน
python3 -m venv venv
source venv/bin/activate # macOS/Linux
venv\Scripts\activate # Windows

# ติดตั้ง SDK
pip install py-clob-client==0.34.6 requests websocket-client python-dotenv

การกำหนดค่าลูกค้าพื้นฐาน

import os
from dotenv import load_dotenv
from py_clob_client.client import ClobClient
from py_clob_client.constants import POLYGON

load_dotenv()

client = ClobClient(
 host="https://clob.polymarket.com",
 key=os.environ["POLY_PRIVATE_KEY"],
 chain_id=POLYGON, # 137
 signature_type=1, # POLY_PROXY
 funder=os.environ["POLY_FUNDER"],
)

# ทำครั้งเดียว: สร้างและแคชข้อมูลรับรอง API
client.set_api_creds(client.create_or_derive_api_creds())

การเรียก create_or_derive_api_creds() จะลงนามข้อความด้วย private key ของคุณและแลกเป็น API key, secret และ passphrase ให้นำข้อมูลเหล่านี้ไปแคชใน .env หลังจากรันครั้งแรก เพื่อไม่ให้ต้องเรียก endpoint สำหรับ derive ทุกครั้งที่เริ่มระบบ

Gamma /markets ส่งกลับ outcomePrices, clobTokenIds, volume24hr, tags ใช้ tag_slug + order=volume24hr เป็นคำค้น scanner bot ค่าเริ่มต้น

ส่วนที่ 4: ค้นหาตลาดผ่าน Gamma

ก่อนที่คุณจะเริ่มเทรด คุณต้องหาตลาดที่คุ้มค่าแก่การเทรดก่อน Gamma จะส่งคืน JSON ที่มีทุกอย่างที่ UI ของ Polymarket แสดงอยู่ - คำถาม, ผลลัพธ์, ราคา, วอลุ่ม 24 ชม., วันหมดอายุ, แท็ก และรูปภาพ

import requests

resp = requests.get(
 "https://gamma-api.polymarket.com/markets",
 params={
 "active": "true",
 "closed": "false",
 "tag_slug": "politics",
 "limit": 20,
 "order": "volume24hr",
 "ascending": "false",
 },
 timeout=10,
)
resp.raise_for_status()
markets = resp.json()

for m in markets:
 print(f"{m['slug']:50} Yes ${float(m['outcomePrices'][0]):.3f} Vol24h ${m.get('volume24hr', 0):,.0f}")

พารามิเตอร์การ query ของ Gamma ที่มีประโยชน์

Gamma เปิดเผย conditionId (หนึ่งรายการต่อหนึ่งตลาด); CLOB เทรดบน token_id (หนึ่งรายการต่อหนึ่งผลลัพธ์) clobTokenIds เป็นอาร์เรย์สตริงที่เข้ารหัสด้วย JSON ซึ่งดัชนีตรงกับผลลัพธ์

ส่วนที่ 5: การแมป condition_id → token_id

นี่คือ จุดเจ็บปวดอันดับ 1 ในการพัฒนาโบต Polymarket Gamma จะส่งคืน condition_id (หนึ่งตัวต่อหนึ่งตลาด) การเทรดบน CLOB ใช้ token_id (หนึ่งตัวต่อหนึ่งผลลัพธ์) คุณต้องมีทั้งสองอย่างเสมอ

# อ็อบเจ็กต์ตลาดแต่ละรายการของ Gamma มี 'clobTokenIds' - อาร์เรย์สตริง JSON
import json

market = markets[0]
token_ids = json.loads(market['clobTokenIds']) # ['7410...', '1120...']
yes_token = token_ids[0] # ผลลัพธ์แรก
no_token = token_ids[1] # ผลลัพธ์ที่สอง

# ทางเลือกอื่น: สอบถาม CLOB โดยตรงโดยใช้ condition_id
info = client.get_market(condition_id=market['conditionId'])
yes_token = info['tokens'][0]['token_id']

ข้อควรระวังเรื่องลำดับของผลลัพธ์

อาร์เรย์ outcomes และอาร์เรย์ clobTokenIds ของ Gamma จะจับคู่กันตามดัชนี ต้อง อ่านป้ายชื่อผลลัพธ์แทนที่จะสมมติว่าดัชนี 0 คือ "Yes" ในตลาดหลายผลลัพธ์ (NegRisk, Oscars, การเลือกตั้ง) ดัชนี 0 อาจเป็น "Kamala Harris" หรือ "Taylor Swift" ก็ได้ - ลำดับถูกกำหนดแน่นอน แต่จะแตกต่างกันไปตามแต่ละตลาด

สมุดคำสั่งซื้อขายแสดงเป็น bid จากสูงไปต่ำ, ask จากต่ำไปสูง ไล่ดูระดับราคาเพื่อประเมินราคาที่จะได้เติมสำหรับมูลค่าเป้าหมายใดๆ ก่อนส่ง FAK ที่คล้าย market

ส่วนที่ 6: การอ่านสมุดคำสั่งซื้อขาย

book = client.get_order_book(token_id=yes_token)

best_bid = float(book.bids[0].price) if book.bids else None
best_ask = float(book.asks[0].price) if book.asks else None
mid = (best_bid + best_ask) / 2 if best_bid and best_ask else None
spread = best_ask - best_bid if best_bid and best_ask else None

print(f"Bid {best_bid} Ask {best_ask} Mid {mid:.4f} Spread {spread:.4f}")

สมุดคำสั่งซื้อขายจะถูกส่งกลับมาเป็นอาร์เรย์ที่เรียงลำดับแล้ว (bids เรียงจากมากไปน้อย, asks เรียงจากน้อยไปมาก) แต่ละระดับมี price และ size หากต้องการประมาณสลิปเพจสำหรับคำสั่งขนาดใหญ่ ให้ไล่ดูสมุดคำสั่งซื้อขายและสะสมมูลค่าตามราคาจนกว่าจะใช้ขนาดเป้าหมายของคุณหมด

GTC ค้างอยู่ในสมุดคำสั่งซื้อขาย, GTD ยกเลิกอัตโนมัติตามเวลา, FOK ต้องเติมเต็มให้ครบทั้งจำนวนหรือยกเลิก, FAK รับเท่าที่ทำได้ในราคาจำกัดแล้วจึงยกเลิกส่วนที่เหลือ

ส่วนที่ 7: การวางคำสั่งซื้อขาย

คำสั่งจำกัดราคา (GTC - ค่าเริ่มต้น)

from py_clob_client.clob_types import OrderArgs, OrderType

args = OrderArgs(
 token_id=yes_token,
 price=0.45,
 size=100, # จำนวนหุ้น ไม่ใช่ดอลลาร์ 100 หุ้นที่ $0.45 = ต้นทุนสูงสุด $45.
 side="BUY",
)
signed_order = client.create_order(args)
response = client.post_order(signed_order, OrderType.GTC)
print(response)

การเรียก create_order จะลงนามข้อความที่มีโครงสร้างแบบ EIP-712 ด้วยคีย์ส่วนตัวของคุณ post_order จะส่งไปยัง CLOB คุณจะไม่ส่งคีย์ส่วนตัวดิบผ่านเครือข่าย - มีเพียงคำสั่งที่ลงนามแล้วเท่านั้น

ประเภทของคำสั่ง

การยกเลิก

# คำสั่งเดี่ยว
client.cancel(order_id="0xabc...")

# ยกเลิกคำสั่งทั้งหมดในตลาดที่ระบุ
client.cancel_market_orders(market=market['conditionId'])

# ทางเลือกนิวเคลียร์: ยกเลิกทั้งหมด
client.cancel_all()

ส่วนที่ 8: การสตรีม WebSocket

การ polling Gamma ทุกวินาทีสิ้นเปลืองและคุณจะชนข้อจำกัดอัตราเร็วอย่างรวดเร็ว ฟีด WebSocket สตรีมการอัปเดตสมุดคำสั่งซื้อขายและการเทรดแบบเรียลไทม์ ด้วยความหน่วงระดับต่ำกว่าหนึ่งวินาที

import json, websocket

WS_URL = "wss://ws-subscriptions-clob.polymarket.com/ws/market"

def on_open(ws):
 ws.send(json.dumps({
 "type": "market",
 "assets_ids": [yes_token, no_token],
 }))

def on_message(ws, message):
 event = json.loads(message)
 if event.get("event_type") == "price_change":
 print(f"{event['market']} {event['side']} {event['price']} size={event['size']}")

ws = websocket.WebSocketApp(
 WS_URL,
 on_open=on_open,
 on_message=on_message,
)
ws.run_forever(ping_interval=20)

มีฟีดอยู่สองแบบ: ฟีด /market (สมุดคำสั่งซื้อขายสาธารณะ + การเทรด) และฟีด /user (อีเวนต์คำสั่งซื้อขายและการเติมของคุณเอง แบบยืนยันตัวตนแล้ว) บ็อตที่ใช้งานจริงโดยทั่วไปจะเชื่อมต่อทั้งสองฟีด เชื่อมต่อใหม่โดยอัตโนมัติเมื่อหลุดการเชื่อมต่อ และถือว่า WebSocket เป็นแหล่งข้อมูลที่เป็นความจริงสำหรับสถานะสมุดคำสั่งปัจจุบัน

ส่วนที่ 9: ขีดจำกัดอัตราและการถอยหลัง

เมื่อคุณเจอ HTTP 429 เซิร์ฟเวอร์จะส่งหัวข้อ Retry-After กลับมา ให้ทำงานแบบ exponential backoff with jitter:

import random, time

def post_with_backoff(fn, *args, max_retries=6):
 for attempt in range(max_retries):
 try:
 return fn(*args)
 except Exception as e:
 if "429" in str(e):
 sleep = (2 ** attempt) + random.random()
 time.sleep(min(sleep, 30))
 continue
 raise
 raise RuntimeError("Too many retries")

ส่วนที่ 10: สถาปัตยกรรมบอทอ้างอิง

บอท Polymarket ที่แข็งแรงทุกตัวมีองค์ประกอบเหมือนกัน 6 ส่วน สร้างแต่ละส่วนเป็นโมดูลของตัวเอง แล้วเชื่อมกันแบบหลวมๆ

ส่วนที่ 11: รูปแบบความล้มเหลวที่พบบ่อย

• ข้อมูล WebSocket ล้าสมัย - ติดตามเวลาของข้อความล่าสุดแยกตามสินทรัพย์; หากไม่มีการอัปเดตเกิน 30 วินาทีในตลาดที่ยังเปิดใช้งาน ให้บังคับรีเฟรชผ่าน REST
• Nonce ชนกัน - py-clob-client จัดการ order nonce ให้คุณ แต่ถ้าคุณเขียน signer เอง ให้เพิ่ม nonce ทุกครั้งที่ส่งคำสั่ง
• ยอดคงเหลือไม่พอ - ตรวจยอดคงเหลือ USDC ทุกครั้งก่อนส่งคำสั่ง; ในสมุดคำสั่งอาจเห็นคำสั่งของคุณ แต่ระบบ matching จะปฏิเสธมัน
• ตลาดหยุดพักหรือกำลังปิดผล - ตรวจ market.active && !market.closed ก่อนเทรด Gamma จะอัปเดตช้ากว่า CLOB อยู่ไม่กี่วินาทีรอบช่วงปิดผล
• NegRisk adapter ไม่ตรงกัน - ตลาดหลายผลลัพธ์จะวิ่งผ่าน NegRisk adapter แยกต่างหาก SDK จัดการให้ แต่ให้ยืนยันว่าคำสั่งของคุณไปยังสถานที่ซื้อขายที่ถูกต้อง

ส่วนที่ 12: รางวัลสภาพคล่องผ่าน API

Polymarket จ่าย ราว $5M/เดือน ในรางวัลสภาพคล่องทั่วไป บวกกับ $5M+/เดือน ในรางวัลเฉพาะกีฬา (ดู Liquidity Rewards) เงินส่วนใหญ่ไหลไปยัง market ผู้ตั้งคำสั่ง (maker) ที่ขับเคลื่อนด้วย API ซึ่งสามารถรักษา quote สองฝั่งที่แคบได้ในตลาดจำนวนมาก

สูตรรางวัลจะให้คะแนนคำสั่งที่อยู่ใกล้ midpoint, ขนาด, และเวลาที่ค้างอยู่ในสมุดคำสั่ง วงจร market making แบบขั้นต่ำ:

1. อ่านสมุดคำสั่งของตลาดเป้าหมาย
2. คำนวณ midpoint ที่เป็นธรรม (เช่น VWAP ของ 3 ระดับบนสุดฝั่งละด้าน)
3. วาง bid ที่ mid − spread_target/2 และ ask ที่ mid + spread_target/2
4. เมื่อมี WebSocket อัปเดตทุกครั้ง ให้ตั้งราคาใหม่ถ้า quote ของคุณห่างจากเป้าหมายเกินหนึ่ง tick
5. ยกเลิกและออกจากตลาดหากสมุดคำสั่งบางลงหรือมีข่าวออกมา

ส่วนที่ 13: ไปสู่โปรดักชัน

• โฮสติ้ง: VPS ราคา $6/เดือน (Hetzner, DigitalOcean) ในยุโรปหรือ US-East ก็พอสำหรับบอทส่วนใหญ่ วางโคโลเคตกับ Polygon RPC หากคุณต้องการ latency ต่ำกว่า 10ms
• RPC: ใช้ Alchemy, Infura, หรือ QuickNode สำหรับ Polygon RPC ที่เชื่อถือได้ แพ็กเกจฟรีก็พอจนกว่าคุณจะส่งคำสั่งหลายร้อยคำสั่งต่อนาที
• การมอนิเตอร์: ใช้ Prometheus + Grafana สำหรับเมตริก; ใช้ Telegram bot สำหรับการแจ้งเตือน บันทึก order ID ทุกอันที่คุณส่งและทุก fill ที่ได้รับ
• แบ็กอัป: บันทึกสถานะทุกนาที หาก VPS ตายระหว่างฟิลล์ คุณควรกลับมาทำงานต่อได้ภายในไม่กี่วินาที ไม่ใช่ต้องไล่ตรวจสอบด้วยมือ
• ภาษี: logger ของคุณคือ audit trail ด้วย - ดู Tax Guide

ส่วนที่ 14 - เคล็ดลับที่ผ่านการยืนยันสำหรับ Polymarket API

Situation → Action Cheat Sheet

ต่อไปคืออะไร?

• เครื่องมือและแหล่งข้อมูล - แดชบอร์ดของบุคคลที่สาม การวิเคราะห์ และฟีดข้อมูลที่เสริม API
• กลยุทธ์ขั้นสูง - อาร์บิทราจหลายช่วงขาและโครงสร้างคล้ายออปชันที่เหมาะสำหรับบอท
• รางวัลสภาพคล่อง - สูตรที่แม่นยำสำหรับการรับส่วนลดค่าธรรมเนียมการเป็นเมกเกอร์
• คู่มือสมุดคำสั่งซื้อขาย - ความเข้าใจเชิงลึกยิ่งขึ้นสำหรับการอ่านสมุดคำสั่งก่อนที่คุณจะเขียนโค้ดโต้ตอบกับมัน
• อภิธานศัพท์ - คำจำกัดความแบบเข้าใจง่ายของทุกคำศัพท์ในคู่มือนี้