วิธีใช้ Kalshi API: คู่มือตลาดทำนาย

จะเกิดอะไรขึ้นถ้าคุณสามารถใช้ API ระดับสถาบันบนตลาดหลักทรัพย์ที่ CFTC กำกับดูแลเพื่อซื้อขายตลาดการคาดการณ์แบบโปรแกรมได้? Kalshi ให้บริการตามนั้น โดยนำเสนออินเทอร์เฟซ REST, WebSocket และ FIX 4.4 สำหรับตลาดการคาดการณ์ที่ได้รับอนุญาตจากรัฐบาลกลางแห่งแรกในสหรัฐอเมริกา ในช่วงครึ่งแรกของปี 2025 เพียงปีเดียว บริษัทสร้างรายได้กว่า 200 ล้านดอลลาร์

ตลาดการคาดการณ์ได้รับความนิยมอย่างมาก แต่นักพัฒนาต้องเลือกระหว่างโครงสร้างพื้นฐานที่มีการกำกับดูแลและความยืดหยุ่นแบบ crypto-native แพลตฟอร์มที่ไม่มีการกำกับดูแลดำเนินการในพื้นที่สีเทาทางกฎหมาย ต้องใช้กระเป๋าเงินบล็อกเชน และทำให้ผู้ใช้มีความเสี่ยงจากสัญญาอัจฉริยะ Kalshi กำจัดจุดเสียดทานเหล่านี้โดยการดำเนินงานในฐานะตลาดสัญญาที่กำหนดภายใต้การกำกับดูแลของ CFTC นำเสนอการชำระบัญชีที่ใช้เงินสกุลปกติ รูปแบบ API แบบดั้งเดิม และการปฏิบัติตามกฎระเบียบทางการเงินของสหรัฐอเมริกา คุณสร้างแอปพลิเคชันการซื้อขายที่สถาบันสามารถใช้งานได้จริง

สารบัญ:

ทำความเข้าใจสถาปัตยกรรมของ Kalshi
การรับรองความถูกต้องและการตั้งค่า
API Endpoints หลัก
ข้อมูลเรียลไทม์ด้วย WebSocket
Kalshi vs Polymarket สำหรับนักพัฒนา
บทสรุป

💡

การสร้างการผสานรวมตลาดการคาดการณ์ต้องอาศัยการทดสอบ API ที่เชื่อถือได้ในโปรโตคอล REST, WebSocket และ FIX Apidog มีฟังก์ชันการทำงาน การทดสอบ API แบบภาพ การสร้าง เอกสารประกอบ โดยอัตโนมัติ และคุณสมบัติการทำงานร่วมกันของทีมที่ออกแบบมาโดยเฉพาะสำหรับแอปพลิเคชันการซื้อขายทางการเงิน ลองใช้ Apidog ฟรีเพื่อปรับปรุงการพัฒนา Kalshi API ของคุณ โดยไม่ต้องใช้บัตรเครดิต

button

ทำความเข้าใจสถาปัตยกรรมของ Kalshi

Kalshi ดำเนินการในฐานะตลาดกลางแบบรวมศูนย์ด้วยสัญญาเหตุการณ์ที่ได้รับการรับรองด้วยตนเอง การทำความเข้าใจสถาปัตยกรรมนี้จะช่วยให้คุณออกแบบการผสานรวมที่แข็งแกร่งได้

สถานะตลาดสัญญาที่กำหนด

Kalshi ถือใบอนุญาต CFTC ที่อนุญาตให้เสนอสัญญาเหตุการณ์ได้อย่างถูกกฎหมายในทุก 50 รัฐของสหรัฐอเมริกา ไม่เหมือนกับการพนันกีฬาที่ควบคุมโดยรัฐ Kalshi ดำเนินการภายใต้เขตอำนาจของรัฐบาลกลาง โดยหลีกเลี่ยงกฎหมายการพนันของรัฐที่กระจัดกระจาย สถานะนี้ต้องการการปฏิบัติตามอย่างเข้มงวด: ทุกตลาดต้องได้รับการตรวจสอบจาก CFTC การชำระบัญชีเป็นไปตามกฎที่เผยแพร่ และตลาดหลักทรัพย์รักษาระบบเฝ้าระวังเพื่อตรวจจับการจัดการ

สมุดคำสั่งซื้อแบบจำกัดส่วนกลาง (CLOB)

Kalshi จับคู่คำสั่งซื้อผ่าน CLOB แบบดั้งเดิม — การเสนอซื้อและการเสนอขายพบกันที่ราคาที่กำหนดพร้อมความลึกที่มองเห็นได้ ซึ่งแตกต่างจาก Automated Market Makers (AMMs) ที่ใช้โดยตลาดซื้อขายแบบกระจายอำนาจ CLOB ให้ความโปร่งใสของราคา อนุญาตให้ใช้คำสั่งซื้อแบบจำกัด และเปิดใช้งานกลยุทธ์การสร้างตลาด ผู้สร้างตลาดได้รับสิ่งจูงใจด้านสภาพคล่องประมาณ 35,000 ดอลลาร์ต่อวัน (เทียบเท่ารายปีประมาณ 12.7 ล้านดอลลาร์) เพื่อให้แน่ใจว่าส่วนต่างราคาแคบแม้ในตลาดที่มีการเคลื่อนไหวไม่มาก

โครงสร้างสัญญาเหตุการณ์

สัญญาแต่ละฉบับแสดงถึงผลลัพธ์แบบไบนารี: ใช่ จ่าย $1.00, ไม่ จ่าย $0.00 ราคาผันผวนระหว่าง $0.01 ถึง $0.99 ซึ่งสะท้อนถึงความน่าจะเป็นที่ตลาดคาดการณ์ สัญญาที่มีการซื้อขายที่ $0.63 หมายถึงโอกาส 63% ที่เหตุการณ์จะเกิดขึ้น การชำระบัญชีจะเกิดขึ้นที่ $1.00 หรือ $0.00 หลังจากการยืนยันผลลัพธ์

สัญญาจะระบุเงื่อนไขการชำระบัญชีที่แน่นอน: คำจำกัดความของเหตุการณ์ แหล่งข้อมูลที่เชื่อถือได้ และระเบียบวิธีแก้ไข ตัวอย่างเช่น สัญญา "CPI จะเกิน 3.5% ในเดือนมกราคมหรือไม่" จะระบุการเปิดเผยข้อมูลของสำนักงานสถิติแรงงานที่แน่นอนและวิธีการตีความการปรับปรุงตามฤดูกาล

Oracle และการชำระบัญชี

Kalshi ใช้ oracle แบบรวมศูนย์ที่ดำเนินการโดยเจ้าหน้าที่ตลาดซื้อขาย ผลลัพธ์จะแก้ไขตามแหล่งข้อมูลทางการ — รายงานของรัฐบาล ผู้ให้บริการข้อมูลที่เชื่อถือได้ หรือองค์กรข่าวที่จัดตั้งขึ้น การแก้ไขมักจะเสร็จสิ้นภายในไม่กี่ชั่วโมงหลังจากการสิ้นสุดของเหตุการณ์ รูปแบบรวมศูนย์นี้ให้ความสำคัญกับความเร็วและความชัดเจนมากกว่าการกระจายอำนาจ โดยมี CFTC กำกับดูแลเพื่อให้เกิดความรับผิดชอบ

การรับรองความถูกต้องและการตั้งค่า

การรับรองความถูกต้องของ Kalshi ต้องใช้คำขอที่ลงชื่อด้วย RSA โดยใช้คีย์ส่วนตัวที่สร้างขึ้นในแดชบอร์ดบัญชีของคุณ ซึ่งให้การตรวจสอบทางเข้ารหัสของ API calls

การตั้งค่าสภาพแวดล้อม

Kalshi มีสองสภาพแวดล้อม:

Demo: https://demo-api.kalshi.co/v1 — ทดสอบด้วยเงินปลอม
Production: https://api.kalshi.com/v1 — การซื้อขายจริงด้วย USD

ควรพัฒนาบนสภาพแวดล้อม Demo ก่อนเสมอ สภาพแวดล้อมทั้งสองทำงานเหมือนกัน แต่ตลาด Demo อาจมีสภาพคล่องจำลอง

การสร้าง API Keys

ไปที่ Settings → API ในแดชบอร์ด Kalshi ของคุณ สร้างคู่คีย์ใหม่:

คลิก "Generate API Key"
เก็บ API Key ID (ขึ้นต้นด้วย kalshi_prod_ หรือ kalshi_demo_)
ดาวน์โหลดคีย์ส่วนตัวทันที — Kalshi จะไม่แสดงอีกครั้ง
รักษาความปลอดภัยของคีย์ส่วนตัวด้วยการอนุญาตไฟล์ (chmod 600)

คีย์ส่วนตัวใช้การลงชื่อแบบ RSA-PSS Kalshi มี SDK อย่างเป็นทางการที่จัดการการลงชื่อโดยอัตโนมัติ หรือคุณสามารถนำไปใช้เองโดยใช้ไลบรารีการเข้ารหัสมาตรฐาน

การติดตั้ง SDK

Kalshi มี SDK อย่างเป็นทางการสำหรับ Python (sync และ async) และ TypeScript:

# Python synchronous
pip install kalshi-python-sync

# Python asynchronous  
pip install kalshi-python-async

# TypeScript/Node.js
npm install @kalshi/sdk

มี SDK ของชุมชนสำหรับ Go และภาษาอื่น ๆ แต่ SDK อย่างเป็นทางการให้การใช้งานการลงชื่อที่น่าเชื่อถือที่สุดและความปลอดภัยของชนิดข้อมูล

การรับรองความถูกต้องด้วยตนเอง (โดยไม่มี SDK)

หากใช้งานการลงชื่อแบบกำหนดเอง ให้ทำตามขั้นตอนดังนี้:

import requests
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
import base64
import json
from datetime import datetime, timezone

class KalshiAuth:
    def __init__(self, api_key_id, private_key_path):
        self.api_key_id = api_key_id
        with open(private_key_path, "rb") as key_file:
            self.private_key = serialization.load_pem_private_key(
                key_file.read(),
                password=None
            )
        self.base_url = "https://api.kalshi.com/v1"
    
    def sign_request(self, method, path, body=None):
        # Create timestamp
        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")[:-3] + "Z"
        
        # Build string to sign
        string_to_sign = f"{timestamp}{method}{path}"
        if body:
            string_to_sign += json.dumps(body, separators=(',', ':'))
        
        # Sign with RSA-PSS
        signature = self.private_key.sign(
            string_to_sign.encode('utf-8'),
            padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=32),
            hashes.SHA256()
        )
        
        return {
            "KALSHI-ACCESS-KEY": self.api_key_id,
            "KALSHI-ACCESS-TIMESTAMP": timestamp,
            "KALSHI-ACCESS-SIGNATURE": base64.b64encode(signature).decode('utf-8'),
            "Content-Type": "application/json"
        }
    
    def request(self, method, path, body=None):
        url = f"{self.base_url}{path}"
        headers = self.sign_request(method, path, body)
        
        if method == "GET":
            response = requests.get(url, headers=headers)
        elif method == "POST":
            response = requests.post(url, headers=headers, json=body)
        elif method == "DELETE":
            response = requests.delete(url, headers=headers)
        
        return response.json()

# Usage
kalshi = KalshiAuth(
    api_key_id="kalshi_prod_abc123",
    private_key_path="~/.kalshi/private_key.pem"
)

# Get markets
markets = kalshi.request("GET", "/markets")
print(markets)

สตริงการลงชื่อรวมถึงเวลา, วิธีการ HTTP, พาธ และเนื้อหา JSON (ถ้ามี) RSA-PSS ด้วย SHA-256 ให้การตรวจสอบทางเข้ารหัสที่ยืนยันว่าคำขอมาจากบัญชีของคุณ

เซสชันที่ใช้โทเค็น

หลังจากการรับรองความถูกต้องเบื้องต้น ให้รับโทเค็นเซสชันสำหรับคำขอถัดไป:

# Login to get session token
login_response = kalshi.request("POST", "/log_in")
session_token = login_response["token"]

# Use token for subsequent requests (valid for 30 minutes)
headers = {
    "Authorization": f"Bearer {session_token}",
    "Content-Type": "application/json"
}

โทเค็นจะหมดอายุทุก 30 นาที ใช้งาน logic การรีเฟรชอัตโนมัติก่อนหมดอายุเพื่อรักษาเซสชันต่อเนื่อง

เคล็ดลับระดับมืออาชีพApidog

API Endpoints หลัก

REST API ของ Kalshi เป็นไปตามข้อตกลงมาตรฐานที่มีโครงสร้าง endpoint ที่มีเหตุผลตามประเภททรัพยากร

ข้อมูลตลาด (สาธารณะ)

ดึงตลาดที่มีอยู่:

curl "https://api.kalshi.com/v1/markets" \
  -H "Content-Type: application/json"

รับรายละเอียดตลาดที่เฉพาะเจาะจง:

curl "https://api.kalshi.com/v1/markets/INXCHI-25JAN31-T69.5" \
  -H "Content-Type: application/json"

รูปแบบ ticker เข้ารหัสรายละเอียดสัญญา: INXCHI-25JAN31-T69.5 แสดงถึงตลาด Inflation/Chicago Fed National Activity Index ที่หมดอายุในวันที่ 31 มกราคม 2025 โดยมีเกณฑ์ 69.5

สอบถามความลึกของสมุดคำสั่งซื้อ:

curl "https://api.kalshi.com/v1/markets/INXCHI-25JAN31-T69.5/orderbook" \
  -H "Content-Type: application/json"

การตอบสนองจะส่งคืนระดับราคาเสนอซื้อและราคาเสนอขายพร้อมปริมาณ ทำให้คุณสามารถประเมินสภาพคล่องก่อนที่จะส่งคำสั่งซื้อ

เคล็ดลับApidog

การดำเนินการซื้อขาย (มีการรับรองความถูกต้อง)

ส่งคำสั่งซื้อ:

order = kalshi.request("POST", "/orders", {
    "market_id": "INXCHI-25JAN31-T69.5",
    "side": "yes",
    "order_type": "limit",
    "price": 6500,  # $0.65 in cents
    "quantity": 100,  # Number of contracts
    "client_order_id": "my-strategy-001"  # Optional tracking ID
})

ราคาของ Kalshi เป็นเซ็นต์ (1 = $0.01) คำสั่งซื้อแบบจำกัดที่ 6500 จะดำเนินการที่ $0.65 หรือดีกว่า

ยกเลิกคำสั่งซื้อที่เปิดอยู่:

kalshi.request("DELETE", f"/orders/{order['id']}")

แสดงรายการคำสั่งซื้อที่เปิดอยู่ของคุณ:

curl "https://api.kalshi.com/v1/orders" \
  -H "Authorization: Bearer $SESSION_TOKEN"

พอร์ตโฟลิโอและบัญชี

ตรวจสอบยอดเงินในบัญชี:

curl "https://api.kalshi.com/v1/portfolio/balance" \
  -H "Authorization: Bearer $SESSION_TOKEN"

ดึงตำแหน่ง:

curl "https://api.kalshi.com/v1/portfolio/positions" \
  -H "Authorization: Bearer $SESSION_TOKEN"

endpoint ตำแหน่งจะส่งคืนการถือครองปัจจุบันของคุณในทุกตลาด รวมถึง P&L ที่ยังไม่เกิดขึ้นจริงตามราคาซื้อขายล่าสุด

รับประวัติการซื้อขาย:

curl "https://api.kalshi.com/v1/portfolio/fills" \
  -H "Authorization: Bearer $SESSION_TOKEN"

Fills รวมถึงคำสั่งซื้อที่ดำเนินการแล้วพร้อมเวลา, ราคา และค่าธรรมเนียมที่ชำระ

การชำระบัญชีและการแก้ไข

สอบถามสถานะการชำระบัญชีสำหรับตลาดที่หมดอายุ:

curl "https://api.kalshi.com/v1/markets/INXCHI-25JAN31-T69.5/settlement" \
  -H "Authorization: Bearer $SESSION_TOKEN"

หลังจากการแก้ไข สัญญาที่ชนะจะได้รับเครดิต $1.00 ต่อหุ้นเข้าบัญชีของคุณ; ตำแหน่งที่แพ้จะถูกชำระที่ $0.00

ข้อมูลเรียลไทม์ด้วย WebSocket

การสำรวจข้อมูลด้วย REST ทำให้เกิดความล่าช้า WebSocket API ของ Kalshi สตรีมข้อมูลอัปเดตสมุดคำสั่งซื้อแบบเรียลไทม์ การดำเนินการซื้อขาย และการเปลี่ยนแปลงสถานะตลาด

การเชื่อมต่อกับ WebSocket

const WebSocket = require('ws');

const ws = new WebSocket('wss://api.kalshi.com/v1/ws', {
  headers: {
    'Authorization': `Bearer ${sessionToken}`
  }
});

ws.on('open', () => {
  console.log('Connected to Kalshi WebSocket');
  
  // Subscribe to order book updates for specific market
  ws.send(JSON.stringify({
    type: 'subscribe',
    channels: ['orderbook:INXCHI-25JAN31-T69.5']
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data);
  
  switch(message.type) {
    case 'orderbook_update':
      console.log('Order book changed:', message.data);
      break;
    case 'trade':
      console.log('Trade executed:', message.data);
      break;
    case 'market_status':
      console.log('Market status:', message.data);
      break;
  }
});

// Heartbeat to maintain connection
setInterval(() => {
  ws.send(JSON.stringify({ type: 'ping' }));
}, 30000);

การเชื่อมต่อ WebSocket ต้องมี heartbeat เป็นระยะ (ทุก 30 วินาที) เพื่อป้องกันการหมดเวลา ใช้งาน logic การเชื่อมต่อใหม่โดยอัตโนมัติสำหรับแอปพลิเคชันเวอร์ชัน Production

ช่องทางการสมัครสมาชิก

ช่องทางที่มีให้เลือก ได้แก่:

orderbook:{market_id} — อัปเดตราคา Bid/Ask
trades:{market_id} — การดำเนินการล่าสุด
market_status:{market_id} — การระงับการซื้อขาย, การชำระบัญชี
user_orders — การเปลี่ยนแปลงสถานะคำสั่งซื้อของคุณ
user_fills — การดำเนินการซื้อขายของคุณ

สมัครสมาชิกหลายช่องทางในข้อความเดียวเพื่อการสตรีมข้อมูลที่มีประสิทธิภาพ

Apidog

Testing APIs With Apidog — ทดสอบ API ด้วย Apidog

button

Kalshi กับ Polymarket สำหรับนักพัฒนา

ทั้งสองแพลตฟอร์มมี API ตลาดการคาดการณ์ แต่สถาปัตยกรรมของพวกเขามีวัตถุประสงค์การใช้งานที่แตกต่างกัน

สถานะการกำกับดูแล

Kalshi ดำเนินงานในฐานะตลาดสัญญาที่กำหนดที่ควบคุมโดย CFTC ซึ่งให้ความชัดเจนทางกฎหมายสำหรับผู้ใช้ในสหรัฐอเมริกา แต่ต้องปฏิบัติตาม KYC/AML และจำกัดการเข้าถึงใน 42 รัฐ (ไม่รวม Arizona, Illinois, Massachusetts, Maryland, Michigan, Montana, New Jersey, Ohio)

Polymarket เพิ่งได้รับการอนุมัติจาก CFTC ผ่านการเข้าซื้อกิจการของ QCX LLC และถือใบอนุญาต DCM พร้อมจดหมาย No-Action ปัจจุบันดำเนินงานระหว่างประเทศโดยมีข้อจำกัดในการเข้าถึงในสหรัฐอเมริกาที่รอการเปิดตัวเต็มรูปแบบ ก่อนหน้านี้ถูกปรับ 1.4 ล้านดอลลาร์สำหรับการดำเนินงานโดยไม่มีการลงทะเบียน (มกราคม 2022)

สถาปัตยกรรมทางเทคนิค

Kalshi ใช้โครงสร้างพื้นฐานแบบรวมศูนย์พร้อมการจับคู่คำสั่งซื้อแบบออฟเชนและการชำระบัญชีด้วย USD แบบ Fiat การเข้าถึง API เป็นไปตามรูปแบบดั้งเดิม: REST ผ่าน HTTPS, WebSocket สำหรับการสตรีม, FIX 4.4 สำหรับการซื้อขายระดับสถาบันที่มีความถี่สูง เวลาตอบสนองวัดเป็นมิลลิวินาที

Polymarket ดำเนินการบนบล็อกเชน Polygon ด้วยสถาปัตยกรรม CLOB แบบผสม — การจับคู่คำสั่งซื้อแบบออฟเชน, การชำระบัญชีแบบออนเชนผ่าน Conditional Tokens Framework การผสานรวมต้องมีการโต้ตอบกับบล็อกเชน: คำสั่งซื้อที่ลงชื่อ EIP-712, การเรียกใช้สัญญาอัจฉริยะ, ธุรกรรม USDC ความสมบูรณ์ของการชำระบัญชีต้องมีการยืนยันจากบล็อกเชน (ไม่กี่วินาทีถึงไม่กี่นาที)

รูปแบบการรับรองความถูกต้อง

Kalshi ใช้คำขอที่ลงชื่อ RSA-PSS พร้อม API key, เซสชันที่ใช้โทเค็นซึ่งหมดอายุทุก 30 นาที ต้องมีการจัดเก็บคีย์ส่วนตัวที่ปลอดภัยและการลงชื่อเข้ารหัส

Polymarket ใช้ลายเซ็นกระเป๋าเงินบล็อกเชน (MetaMask, WalletConnect) ผู้ใช้ลงชื่อคำสั่งซื้อด้วยคีย์ส่วนตัวที่ควบคุมที่อยู่ Polygon ของตน ไม่มีโทเค็นเซสชัน — แต่ละธุรกรรมต้องมีลายเซ็นใหม่

สกุลเงินที่ใช้ชำระบัญชี

Kalshi ชำระบัญชีเป็น USD ผ่านการโอนเงินผ่านธนาคาร, ACH, บัตรเดบิต, PayPal, Apple Pay, Google Pay การถอนขั้นต่ำมักจะอยู่ที่ $10 ระยะเวลาดำเนินการ 1-3 วันทำการสำหรับ ACH เร็วกว่าสำหรับการโอนเงิน

Polymarket ชำระบัญชีเป็น USDC บนบล็อกเชน Polygon การชำระบัญชีทันทีเมื่อแก้ไข แต่ต้องมีกระเป๋าเงินคริปโตและโครงสร้างพื้นฐาน on-ramp/off-ramp มีค่าธรรมเนียม gas สำหรับการถอน

โปรโตคอล API

Kalshi มีสามโปรโตคอล:

REST: HTTP มาตรฐานสำหรับการดำเนินการทั้งหมด
WebSocket: การสตรีมแบบเรียลไทม์สำหรับข้อมูลตลาดและการอัปเดตคำสั่งซื้อ
FIX 4.4: โปรโตคอลมาตรฐานอุตสาหกรรมสำหรับการซื้อขายความถี่สูงระดับสถาบัน

Polymarket ต้องใช้:

GraphQL: การสอบถามที่ยืดหยุ่นสำหรับข้อมูลบล็อกเชน
EIP-712: การลงชื่อข้อมูลแบบมีประเภทสำหรับคำสั่งซื้อ
Smart Contract Calls: การโต้ตอบกับบล็อกเชนโดยตรงสำหรับการชำระบัญชี

คำแนะนำการใช้งาน

เลือก Kalshi สำหรับ:

แผนกการซื้อขายระดับสถาบันที่ต้องการการปฏิบัติตามกฎระเบียบ
แอปพลิเคชันที่ให้บริการผู้ใช้ค้าปลีกในสหรัฐอเมริกา
Fiat on/off ramps โดยไม่มีความซับซ้อนของคริปโต
การซื้อขายด้วยอัลกอริทึมที่มีความหน่วงต่ำ
การผสานรวมทางการเงินแบบดั้งเดิม

เลือก Polymarket สำหรับ:

โปรโตคอล DeFi ที่ต้องการความสามารถในการรวมสัญญาอัจฉริยะ
ผู้ใช้ทั่วโลกนอกเขตอำนาจศาลของสหรัฐอเมริกา
แอปพลิเคชันที่ใช้คริปโตโดยมีโครงสร้างพื้นฐานกระเป๋าเงินที่มีอยู่แล้ว
การสร้างตลาดอย่างรวดเร็ว (เป็นชั่วโมงเทียบกับเป็นวันสำหรับการอนุมัติ)
การตรวจสอบและความโปร่งใสบนเชน

ความซับซ้อนของการผสานรวม

การผสานรวม Kalshi ต้องใช้เวลา 2-4 สัปดาห์สำหรับข้อมูลตลาดพื้นฐานและฟังก์ชันการซื้อขาย โดยสมมติว่ามีประสบการณ์กับ REST API รูปแบบ HTTP ที่คุ้นเคยช่วยลดระยะเวลาการเรียนรู้

การผสานรวม Polymarket ต้องใช้เวลา 3-6 เดือนสำหรับตลาดสัญญาอัจฉริยะที่พร้อมใช้งานจริง รวมถึงการตรวจสอบความปลอดภัย (งบประมาณ $50K-$200K) การผสานรวม oracle และการสร้างสภาพคล่อง ความเชี่ยวชาญด้านบล็อกเชนเป็นสิ่งจำเป็น

โครงสร้างต้นทุน

Kalshi คิดค่าธรรมเนียมการซื้อขายตามรายได้ที่คาดการณ์ไว้ (0.7-3.5% โดยเฉลี่ย 0.8%) การเข้าถึง API ฟรี — คุณจ่ายเฉพาะค่าธรรมเนียมการซื้อขายเท่านั้น ไม่มีค่าธรรมเนียมการถอนสำหรับ ACH

Polymarket คิดค่าธรรมเนียมผู้รับ 0.01% สำหรับตลาดหลัก พร้อมค่าธรรมเนียม gas สำหรับธุรกรรมบล็อกเชน ไม่มีค่าธรรมเนียมในบางตลาด แต่มีค่าใช้จ่ายเครือข่าย

บทสรุป

API ของ Kalshi ให้การเข้าถึงตลาดการคาดการณ์ที่ได้รับการควบคุมผ่านโปรโตคอล REST และ WebSocket ที่คุ้นเคย คุณรับรองความถูกต้องด้วยคำขอที่ลงชื่อด้วย RSA ซื้อขายสัญญาเหตุการณ์ผ่านสมุดคำสั่งซื้อแบบจำกัดส่วนกลาง และชำระบัญชีเป็น USD ผ่านธนาคารแบบดั้งเดิม การกำกับดูแลของ CFTC ทำให้มั่นใจได้ถึงการปฏิบัติตามกฎหมายสำหรับแอปพลิเคชันในสหรัฐอเมริกา ในขณะที่รายได้ 200 ล้านดอลลาร์ต่อปีแสดงให้เห็นถึงความเป็นไปได้ระดับสถาบัน

เริ่มต้นด้วยสภาพแวดล้อม Demo เพื่อทดสอบรูปแบบการผสานรวม ใช้งานการจัดการคีย์ที่เหมาะสมและการลงชื่อคำขอก่อนที่จะย้ายไปยังเวอร์ชัน Production ใช้การสตรีม WebSocket สำหรับแอปพลิเคชันเรียลไทม์ที่ต้องการความหน่วงต่ำ ตรวจสอบการหมดอายุโทเค็น 30 นาทีและใช้งาน logic การรีเฟรชเพื่อการทำงานต่อเนื่อง

เริ่มต้นกับ Apidog วันนี้ — นำเข้า API endpoints ของ Kalshi ของคุณในไม่กี่วินาทีและเริ่มทดสอบกลยุทธ์ตลาดการคาดการณ์ของคุณโดยไม่ต้องกำหนดค่าใดๆ

button