สารบัญ

ภาพรวม การตรวจสอบสิทธิ์ด้วย API Key รูปแบบ Bearer Token การใช้งาน OAuth 2.0 การจัดการ JWT Token กลยุทธ์การหมุนคีย์ การตรวจสอบสิทธิ์หลายปัจจัย แนวปฏิบัติด้านความปลอดภัยที่ดีที่สุด รูปแบบสำหรับองค์กร การแก้ไขปัญหา

เอกสาร API

รูปแบบการตรวจสอบสิทธิ์ขั้นสูง — OAuth 2.0, JWT, การหมุนคีย์

เรียนรู้กลไกการตรวจสอบสิทธิ์ที่ซับซ้อนสำหรับการรวม Smart Money API ในสภาพแวดล้อมองค์กร เรียนรู้การไหลของ OAuth 2.0 รูปแบบ JWT token การหมุนคีย์ที่ปลอดภัย และการใช้งานการตรวจสอบสิทธิ์หลายปัจจัย

เผยแพร่เมื่อ 21 มีนาคม 2026 • อ่าน 18 นาที • ขั้นสูง

ภาพรวมการตรวจสอบสิทธิ์

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

การตรวจสอบสิทธิ์ใน Smart Money API ทำงานผ่านสามชั้นหลัก:

API Keys — การตรวจสอบสิทธิ์ด้วย Bearer Token แบบง่ายสำหรับการพัฒนาและการรวมที่ตรงไปตรงมา
JWT Tokens — Token ที่ไม่มีสถานะและมีการลงนามด้วยการเข้ารหัสสำหรับระบบกระจายและไมโครเซอร์วิส
OAuth 2.0 — กรอบการอนุญาตแบบมอบหมายสำหรับการรวมกับบุคคลที่สามและแอปพลิเคชัน SaaS

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

แต่ละวิธีมีข้อดีที่แตกต่างกัน API keys ทำงานได้ดีที่สุดสำหรับการสื่อสารระหว่าง backend ที่มีการควบคุมการจัดเก็บข้อมูลประจำตัว JWT tokens เหมาะสำหรับสถาปัตยกรรมกระจายที่ไม่มีสถานะร่วมกัน OAuth 2.0 ให้การเข้าถึงที่มอบหมายจากผู้ใช้สำหรับแอปพลิเคชันบุคคลที่สาม

API Key Authentication

API keys เป็นกลไกการยืนยันตัวตนที่ง่ายที่สุด—เป็นสตริงแบบสุ่มที่สร้างขึ้นสำหรับบัญชีของคุณเพื่อระบุแอปพลิเคชันของคุณกับ Smart Money API ทุกคำขอต้องรวม API key ของคุณไว้ในส่วนหัวหรือพารามิเตอร์คำขอ

Header-Based API Key

วิธีที่แนะนำคือส่ง API key ของคุณในส่วนหัว Authorization โดยใช้รูปแบบ Bearer:

curl Example
curl -X GET "https://api.smartmoneyapi.com/v1/whales/btc" \
  -H "Authorization: Bearer sk_live_1234567890abcdef" \
  -H "Accept: application/json"

Query Parameter API Key

สำหรับการเชื่อมต่อ WebSocket หรือเมื่อไม่สามารถแก้ไขส่วนหัวได้ ให้ส่ง API key เป็นพารามิเตอร์คำขอ:

WebSocket Connection
ws://localhost:8877/ws?api_key=sk_live_1234567890abcdef
// สร้างการเชื่อมต่อ WebSocket ที่ผ่านการยืนยันตัวตน

API Key Characteristics

คุณสมบัติ	คำอธิบาย
รูปแบบ	สตริงฐานสิบหก 128 ตัวอักษร นำหน้าด้วย sk_test_ หรือ sk_live_
ขอบเขต	สืบทอดสิทธิ์ทั้งหมดของบัญชีที่สร้างมันขึ้นมา
การหมดอายุ	ไม่หมดอายุโดยอัตโนมัติ ต้องหมุนเวียนด้วยตนเอง
การหมุนเวียน	สร้างคีย์ใหม่ ย้ายการใช้งาน แล้วปิดการใช้งานคีย์เก่า
Rate Limits	ใช้ร่วมกันกับการร้องขอทั้งหมดที่ใช้คีย์เดียวกัน

API Key Security Practices

Environment Variables — เก็บคีย์ไว้ในไฟล์ .env (ไม่เก็บไว้ในระบบควบคุมเวอร์ชัน) และโหลดเมื่อรันไทม์
Vault Systems — ใช้งาน HashiCorp Vault, AWS Secrets Manager หรือ Azure Key Vault ในสภาพแวดล้อมการผลิต
แยกคีย์ — รักษาคีย์ทดสอบและคีย์ใช้งานจริงแยกจากกัน หมุนเวียนคีย์ทดสอบบ่อยครั้ง
ขอบเขตที่จำกัด — สร้างคีย์แยกสำหรับการเชื่อมต่อต่าง ๆ เมื่อทำได้
บันทึกการตรวจสอบ — บันทึกเหตุการณ์การสร้างและการใช้งานคีย์ API ทั้งหมด

รับคีย์ API ของคุณใน 30 วินาที

พร้อมสร้างแล้วใช่ไหม? รับคีย์ API ฟรี (100 ครั้ง/วัน ไม่ต้องใช้บัตร) และเริ่มดึงข้อมูลวาฬ ข้อมูลฟันดิ้ง และข้อมูลออนเชนแบบเรียลไทม์

รับคีย์ API ของคุณ →

รูปแบบ Bearer Token

Bearer tokens ขยายแนวคิดคีย์ API ธรรมดาโดยเพิ่มบริบท ระยะเวลาหมดอายุ และกลไกการรีเฟรช เหมาะสำหรับแอปพลิเคชันที่ต้องการการจัดการข้อมูลประจำตัวแบบโปรแกรมได้

การรับ Bearer Tokens

แลกคีย์ API และรหัสลับของคุณเพื่อรับ bearer token ที่ใช้งานได้ 24 ชั่วโมง:

GET /auth/token
curl -X POST "https://api.smartmoneyapi.com/v1/auth/token" \
  -H "Content-Type: application/json" \
  -d '{
 "api_key": "sk_live_1234567890",
 "api_secret": "secret_abc123xyz"
  }'

รูปแบบการตอบสนองของ Token

เอนด์พอยต์จะคืนค่า bearer token พร้อมข้อมูลเมตา:

การตอบสนอง
{
 "access_token": "eyJhbGciOiJIUzI1NiIs...",
 "token_type": "Bearer",
 "expires_in": 86400,
 "refresh_token": "refresh_1234567..."
}

การใช้ Bearer Tokens

ใส่ token ในส่วนหัว Authorization สำหรับคำขอทั้งหมดที่ตามมา:

คำขอที่ได้รับการตรวจสอบสิทธิ์
curl -X GET "https://api.smartmoneyapi.com/v1/derivatives/funding-heatmap" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIs..."

กระบวนการรีเฟรช Token

เมื่อ token ใกล้หมดอายุ ใช้ refresh token เพื่อรับ token ใหม่โดยไม่ต้องใช้ API secret ของคุณ:

POST /auth/refresh
curl -X POST "https://api.smartmoneyapi.com/v1/auth/refresh" \
  -H "Content-Type: application/json" \
  -d '{
 "refresh_token": "refresh_1234567..."
  }'

การนำ OAuth 2.0 มาใช้

OAuth 2.0 ช่วยให้ผู้ใช้สามารถมอบสิทธิ์การเข้าถึงบัญชี Smart Money API ให้กับแอปพลิเคชันโดยไม่ต้องแชร์ข้อมูลประจำตัว สิ่งนี้จำเป็นสำหรับแพลตฟอร์ม SaaS การเชื่อมต่อของบุคคลที่สาม และแอปพลิเคชันแบบหลายผู้เช่า

กระบวนการ Authorization Code Flow ของ OAuth 2.0

กระบวนการมาตรฐานสำหรับแอปพลิเคชันเว็บ:

ผู้ใช้เริ่มเข้าสู่ระบบ — ผู้ใช้คลิก "เชื่อมต่อกับ Smart Money API"
เปลี่ยนเส้นทางไปยังเซิร์ฟเวอร์การอนุญาต — แอปของคุณเปลี่ยนเส้นทางผู้ใช้ไปยังเอนด์พอยต์การอนุญาตของ Smart Money
ผู้ให้สิทธิ์อนุญาต — ผู้ใช้ตรวจสอบขอบเขตที่ขอและให้สิทธิ์การเข้าถึง
ได้รับรหัสการอนุญาต — ผู้ใช้ถูกเปลี่ยนเส้นทางกลับพร้อมรหัสการอนุญาต
แลกรหัสเพื่อรับ Token — แบ็กเอนด์แลกรหัสเพื่อรับ access token (รหัสจะไม่ถูกเปิดเผยที่ส่วนหน้า)
เก็บ Token — เก็บ refresh token อย่างปลอดภัย; ใช้ access token สำหรับการเรียก API

ขั้นตอนที่ 1: นำผู้ใช้ไปยังจุดสิ้นสุดการอนุญาต

การเปลี่ยนเส้นทาง Frontend
// URL เพื่อเปลี่ยนเส้นทางผู้ใช้ไปยัง
const authUrl = new URL('https://api.smartmoneyapi.com/oauth/authorize');
authUrl.searchParams.append('client_id', 'your_client_id');
authUrl.searchParams.append('redirect_uri', 'https://yourapp.com/callback');
authUrl.searchParams.append('response_type', 'code');
authUrl.searchParams.append('scope', 'whales derivatives onchain');
authUrl.searchParams.append('state', generateRandomState());
window.location.href = authUrl.toString();

ขั้นตอนที่ 2: จัดการ Callback และแลกเปลี่ยน Code

การแลกเปลี่ยน Code ใน Backend
// Backend จัดการเส้นทาง /callback
const code = req.query.code;
const storedState = req.session.state;
const receivedState = req.query.state;
// ตรวจสอบพารามิเตอร์ state
if (storedState !== receivedState) {
  throw new Error('State mismatch - CSRF attack detected');
}
// แลกเปลี่ยน code เพื่อรับ token
const tokenResponse = await fetch('https://api.smartmoneyapi.com/oauth/token', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    grant_type: 'authorization_code',
    code: code,
    client_id: process.env.OAUTH_CLIENT_ID,
    client_secret: process.env.OAUTH_CLIENT_SECRET,
    redirect_uri: 'https://yourapp.com/callback'
  })
});
const tokens = await tokenResponse.json();
// เก็บ token อย่างปลอดภัย

ขอบเขต OAuth

ขอเฉพาะขอบเขตที่แอปพลิเคชันของคุณต้องการ Smart Money API กำหนดขอบเขตเหล่านี้:

ขอบเขต	คำอธิบาย
whales	เข้าถึงการติดตามกระเป๋าเงินของวาฬและเมตริกการสะสม
derivatives	เข้าถึงข้อมูลฟิวเจอร์ส, perpetuals และอัตราการระดมทุน
onchain	เข้าถึงการไหลของธุรกรรมบนเชนและการวิเคราะห์
alerts	สร้างและจัดการการแจ้งเตือนผ่านเว็บฮุค
offline	เข้าถึง refresh tokens เพื่อรับ access tokens ใหม่แบบออฟไลน์

การจัดการ JWT Token

JWT (JSON Web Tokens) ให้การตรวจสอบสิทธิ์แบบไร้สถานะ—เซิร์ฟเวอร์ไม่จำเป็นต้องเก็บข้อมูลเซสชัน Smart Money API ใช้ RS256 (RSA Signature with SHA-256) สำหรับการลงนาม token ทำให้สามารถตรวจสอบได้โดยไม่ต้องติดต่อ API

โครงสร้าง JWT

JWT tokens ประกอบด้วยสามส่วนที่คั่นด้วยจุด:

รูปแบบ JWT
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6IjEifQ.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFjY3QxMjM0In0.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
// HEADER.PAYLOAD.SIGNATURE

ส่วนหัว JWT

ส่วนหัวระบุอัลกอริทึมและประเภทของ token:

ส่วนหัวที่ถอดรหัสแล้ว
{
 "alg": "RS256",
 "typ": "JWT",
 "kid": "1"
}

ข้อมูลใน Payload ของ JWT

payload ประกอบด้วย claims (คำสั่งเกี่ยวกับผู้ใช้/แอป):

payload ที่ถอดรหัสแล้ว
{
 "sub": "acct_1234567890",
 "name": "Trading Bot",
 "iat": 1703001600,
 "exp": 1703088000,
 "scopes": ["whales", "derivatives"],
 "aud": "https://api.smartmoneyapi.com"
}

การตรวจสอบลายเซ็น JWT

ดาวน์โหลด public key ของ Smart Money และตรวจสอบ tokens ก่อนยอมรับ:

การตรวจสอบใน Node.js
const jwt = require('jsonwebtoken');
const fs = require('fs');
// รับ public key จาก Smart Money API
const publicKey = fs.readFileSync('smartmoney-public.pem');
// ตรวจสอบ token
try {
  const decoded = jwt.verify(token, publicKey, {
    algorithms: ['RS256'],
    audience: 'https://api.smartmoneyapi.com',
    issuer: 'https://api.smartmoneyapi.com'
  });
  // Token ถูกต้อง ใช้ claims ที่ถอดรหัสแล้ว
} catch (err) {
  // Token ไม่ถูกต้องหรือหมดอายุ
}

กลยุทธ์การหมุนคีย์

การหมุนคีย์เป็นประจำมีความสำคัญสำหรับการรักษาความปลอดภัย แม้จะมีแนวทางปฏิบัติด้านความปลอดภัยที่สมบูรณ์แบบ ให้ถือว่าคีย์อาจถูกโจมตีและดำเนินการหมุนคีย์อย่างเป็นระบบ

ความถี่ในการหมุน

Smart Money แนะนำตารางการหมุนที่แตกต่างกันตามประเภทและการใช้งานของคีย์:

ประเภทคีย์	แนะนำให้หมุน	หมุนขั้นต่ำ
คีย์ API ทดสอบ	รายเดือน	รายไตรมาส
คีย์ API สำหรับการผลิต	รายไตรมาส	รายปี
OAuth Refresh Tokens	อัตโนมัติ (หลังจาก 90 วัน)	มือถือ (หลังจาก 180 วัน)
คีย์บัญชีบริการ	ทุกครึ่งปี	รายปี

กระบวนการหมุนคีย์แบบไม่หยุดทำงาน

หมุนคีย์โดยไม่หยุดให้บริการ:

สร้างคีย์ใหม่ — สร้างคีย์ API ใหม่ผ่านแดชบอร์ดหรือ API
ปรับใช้คีย์ใหม่ — อัปเดตข้อมูลลับของแอปพลิเคชันใน staging ทดสอบอย่างละเอียด
การเปิดตัวแบบค่อยเป็นค่อยไป — ปรับใช้กับ 10% ของเซิร์ฟเวอร์ ตรวจสอบข้อผิดพลาด
การเปิดใช้งานเต็มรูปแบบ — นำไปใช้งานกับเซิร์ฟเวอร์ที่เหลือ
ตรวจสอบการรับส่งข้อมูล — ยืนยันว่าคำขอทั้งหมดใช้คีย์ใหม่
ปิดใช้งานคีย์เก่า — ตั้งค่าคีย์เก่าเป็นไม่ใช้งาน แต่ยังไม่ลบทันที
ลบคีย์เก่า — หลังจาก 48 ชั่วโมงโดยไม่มีข้อผิดพลาด ให้ลบอย่างถาวร

การหมุนคีย์กรณีฉุกเฉิน

หากคุณสงสัยว่าคีย์ถูกโจมตี:

การหมุนคีย์ฉุกเฉิน
// การดำเนินการทันที: ปิดใช้งานคีย์ที่ถูกโจมตี
curl -X POST "https://api.smartmoneyapi.com/v1/keys/sk_live_xxx/revoke" \
  -H "Authorization: Bearer token"
// สร้างคีย์ทดแทนทันที
curl -X POST "https://api.smartmoneyapi.com/v1/keys" \
  -H "Content-Type: application/json" \
  -d '{
 "name": "Emergency Replacement Key"
  }'

การหมุนคีย์อัตโนมัติใน Kubernetes

ใช้ Kubernetes Secrets และ operators สำหรับการหมุนคีย์อัตโนมัติ:

CronJob สำหรับการหมุนคีย์
apiVersion: batch/v1
kind: CronJob
metadata:
  name: api-key-rotator
spec:
  schedule: "0 0 * * 0"  # ทุกสัปดาห์ในวันอาทิตย์
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: rotator
            image: smartmoney-key-rotator:latest

การยืนยันตัวตนหลายปัจจัย (MFA)

สำหรับบัญชีที่เข้าถึงข้อมูลการผลิต MFA ให้ชั้นความปลอดภัยเพิ่มเติมโดยต้องมีปัจจัยที่สองนอกเหนือจากข้อมูลประจำตัว

วิธีการ MFA ที่รองรับ

TOTP (รหัสผ่านครั้งเดียวตามเวลา) — แอปเช่น Google Authenticator, Authy
WebAuthn/FIDO2 — คีย์ความปลอดภัยทางฮาร์ดแวร์, ชีวมิติ
รหัสครั้งเดียวผ่าน SMS — ความปลอดภัยน้อยกว่าแต่รองรับทั่วไป
การยืนยันทางอีเมล — ส่งรหัสยืนยันไปยังอีเมลที่ลงทะเบียน

เปิดใช้งาน TOTP สำหรับการเข้าถึงบัญชี

เปิดใช้งาน MFA
// ขั้นตอนที่ 1: ขอตั้งค่า MFA
curl -X POST "https://api.smartmoneyapi.com/v1/account/mfa/enable" \
  -H "Authorization: Bearer token"
// การตอบกลับรวมถึง URL QR code
{
 "qr_code_url": "https://...",
 "secret": "JBSWY3DPEBLW64TMMQ...",
 "backup_codes": ["12345678", ...]
}

MFA ในระหว่างการดำเนินการ API

บางการดำเนินการอาจต้องมีการยืนยัน MFA แม้หลังการยืนยันตัวตน:

การท้าทาย MFA
// พยายามดำเนินการที่ละเอียดอ่อน (การหมุนคีย์)
curl -X POST "https://api.smartmoneyapi.com/v1/keys/rotate" \
  -H "Authorization: Bearer token" \
  -H "X-MFA-Token: mfa_challenge_abc123"
// การตอบกลับ: ต้องใช้ MFA
{
 "error": "mfa_required",
 "mfa_token": "mfa_xyz789"
}
// ลองใหม่ด้วยรหัส TOTP
curl -X POST "https://api.smartmoneyapi.com/v1/keys/rotate" \
  -H "Authorization: Bearer token" \
  -H "X-MFA-Code: 123456"

แนวทางปฏิบัติด้านความปลอดภัยที่ดีที่สุด

การยืนยันตัวตนจะแข็งแกร่งเท่ากับการนำไปปฏิบัติ ใช้แนวทางเหล่านี้เพื่อรักษาความปลอดภัย:

การจัดการความลับ

อย่าเก็บความลับในระบบควบคุมเวอร์ชัน — ใช้ไฟล์ .env พร้อม .gitignore
ใช้ตัวแปรสภาพแวดล้อม — โหลดจากระบบการจัดการความลับที่ปลอดภัย
สแกนที่เก็บข้อมูล — ใช้เครื่องมือเช่น TruffleHog, detect-secrets เพื่อหาคีย์ที่เปิดเผย
ตรวจสอบบันทึกการเข้าถึง — ตรวจสอบว่าใครเข้าถึงความลับและเมื่อไหร่

ความปลอดภัยในการขนส่ง

ใช้ HTTPS เสมอ — อย่าส่งข้อมูลประจำตัวผ่านการเชื่อมต่อที่ไม่ได้เข้ารหัส
ตรวจสอบใบรับรอง SSL — อย่าปิดการตรวจสอบใบรับรองในการผลิต
ใช้การปักหมุดใบรับรอง — สำหรับแอปมือถือ ป้องกันการโจมตี MITM
บังคับใช้ TLS 1.2+ — ปิดใช้งานโปรโตคอลเก่า

การจัดการข้อมูลประจำตัว

แฮชความลับ — เก็บแฮช bcrypt หรือ Argon2 อย่าเก็บเป็นข้อความธรรมดา
ลดระยะเวลาการใช้งาน — เก็บข้อมูลประจำตัวในหน่วยความจำเท่าที่จำเป็น
ล้างข้อมูลที่ละเอียดอ่อน — เขียนทับข้อมูลประจำตัวหลังใช้อย่างชัดเจน
ใช้ไลบรารีที่ปลอดภัย — อย่าเข้ารหัสด้วยตัวเอง

การบันทึกและการตรวจสอบ

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

รูปแบบการยืนยันตัวตนสำหรับองค์กร

องค์กรขนาดใหญ่มักต้องการการควบคุมความปลอดภัยเพิ่มเติมและความสามารถในการปฏิบัติตามข้อกำหนด

การรวม SAML 2.0

สำหรับลูกค้าระดับองค์กร Smart Money API รองรับการรวม SAML 2.0 กับผู้ให้บริการตัวตนขององค์กรของคุณ (Okta, Azure AD เป็นต้น):

Single Sign-On (SSO) — ผู้ใช้ยืนยันตัวตนผ่าน IdP ขององค์กร
การจัดเตรียมอัตโนมัติ — สร้าง/ปิดใช้งานบัญชีตามสมาชิกกลุ่ม
การบังคับใช้ — ต้องใช้ SAML สำหรับการเข้าถึงผู้ใช้ทั้งหมด

การอนุญาตตาม IP

จำกัดการเข้าถึง API เฉพาะที่อยู่ IP หรือช่วง CIDR ที่ระบุ:

การจัดการ IP Whitelist
// เพิ่ม IP เข้า whitelist
curl -X POST "https://api.smartmoneyapi.com/v1/account/ip-whitelist" \
  -H "Authorization: Bearer token" \
  -d '{
 "cidr": "203.0.113.0/24",
 "description": "เซิร์ฟเวอร์สำหรับใช้งานจริง"
  }'

การบันทึกตรวจสอบและความสอดคล้อง

แผนระดับองค์กรรวมบันทึกตรวจสอบที่ครอบคลุมเพื่อความสอดคล้อง:

เหตุการณ์	ข้อมูลที่บันทึก
การตรวจสอบสิทธิ์	ผู้ใช้, เวลา, สำเร็จ/ล้มเหลว, IP, สถานะ MFA
การดำเนินการกับคีย์	รหัสคีย์, การดำเนินการ, ผู้เริ่มต้น, เวลา
การเปลี่ยนแปลงบัญชี	สิ่งที่เปลี่ยนแปลง, ผู้ที่เปลี่ยนแปลง, เวลา, ค่าก่อน/หลัง
การเข้าถึงข้อมูล	ผู้ใช้, endpoint, ขอบเขต, เวลา, จำนวนบันทึก

การแก้ไขปัญหาการตรวจสอบสิทธิ์

ข้อผิดพลาดคีย์ API ไม่ถูกต้อง

ปัญหา: ได้รับ "401 Unauthorized - Invalid API Key"

วิธีแก้ไข:

ตรวจสอบรูปแบบคีย์ (ควรขึ้นต้นด้วย sk_test_ หรือ sk_live_)
ตรวจสอบช่องว่างก่อน/หลังในคีย์
ยืนยันว่าคีย์ยังไม่ถูกยกเลิกหรือเปลี่ยน
ตรวจสอบว่าคุณใช้สภาพแวดล้อมที่ถูกต้อง (คีย์ทดสอบสำหรับการทดสอบ, คีย์จริงสำหรับใช้งาน)
ตรวจสอบสิทธิ์คีย์ API ให้ตรงกับความต้องการของ endpoint

ข้อผิดพลาดโทเค็นหมดอายุ

ปัญหา: โทเค็น Bearer หมดอายุ, การร้องขอล้มเหลว

วิธีแก้ไข:

ใช้ refresh token เพื่อรับ access token ใหม่
ดำเนินการรีเฟรชโทเค็นอัตโนมัติ 5 นาทีก่อนหมดอายุ
เก็บ refresh token อย่างปลอดภัย (ไม่ใช่ใน localStorage สำหรับ SPAs)
จัดการการตอบสนอง 401 โดยลองใช้กระบวนการรีเฟรชโทเค็น

ข้อผิดพลาด CORS/Preflight

ปัญหา: เบราว์เซอร์บล็อกการร้องขอด้วยข้อผิดพลาด CORS

วิธีแก้ไข:

การเรียก API จากเบราว์เซอร์ต้องมาจาก origin ที่อยู่ใน whitelist
เพิ่มโดเมนของคุณผ่านแดชบอร์ด: Settings → CORS Origins
เบราว์เซอร์ส่งคำขอ preflight OPTIONS อัตโนมัติ
สำหรับการพัฒนา ใช้ localhost:3000 หรือคล้ายกัน

การท้าทาย MFA ไม่สำเร็จ

ปัญหา: การดำเนินการที่ต้องการ MFA ล้มเหลวแม้ใส่รหัสถูกต้อง

วิธีแก้ไข:

ตรวจสอบว่าเวลาของเซิร์ฟเวอร์ตรงกัน (TOTP ขึ้นอยู่กับเวลา)
รหัสใช้ได้เพียง 30 วินาทีเท่านั้น สร้างรหัสใหม่
ใช้รหัสสำรองหากแอปตรวจสอบสิทธิ์ไม่พร้อมใช้งาน
สามารถกู้คืนบัญชีผ่านอีเมลที่ลงทะเบียนไว้

เริ่มต้นใช้การตรวจสอบสิทธิ์ที่ปลอดภัยวันนี้

Smart Money API รองรับการตรวจสอบสิทธิ์ระดับองค์กรด้วย OAuth 2.0, JWT, MFA และการรวม SAML ปรับใช้การเชื่อมต่อ API ของคุณด้วยแนวทางปฏิบัติที่ดีที่สุดในอุตสาหกรรม

ดูแผนระดับองค์กร

ต้องการ SAML, IP whitelisting หรือการสนับสนุนเฉพาะ? ติดต่อทีมขายของเรา

รูปแบบการตรวจสอบสิทธิ์ขั้นสูง — OAuth 2.0, JWT, การหมุนคีย์

ภาพรวมการตรวจสอบสิทธิ์

API Key Authentication

Header-Based API Key

Query Parameter API Key

API Key Characteristics

API Key Security Practices

รูปแบบ Bearer Token

การรับ Bearer Tokens

รูปแบบการตอบสนองของ Token

การใช้ Bearer Tokens

กระบวนการรีเฟรช Token

การนำ OAuth 2.0 มาใช้

กระบวนการ Authorization Code Flow ของ OAuth 2.0

ขั้นตอนที่ 1: นำผู้ใช้ไปยังจุดสิ้นสุดการอนุญาต

ขั้นตอนที่ 2: จัดการ Callback และแลกเปลี่ยน Code

ขอบเขต OAuth

การจัดการ JWT Token

โครงสร้าง JWT

ส่วนหัว JWT

ข้อมูลใน Payload ของ JWT

การตรวจสอบลายเซ็น JWT

กลยุทธ์การหมุนคีย์

ความถี่ในการหมุน

กระบวนการหมุนคีย์แบบไม่หยุดทำงาน

การหมุนคีย์กรณีฉุกเฉิน

การหมุนคีย์อัตโนมัติใน Kubernetes

การยืนยันตัวตนหลายปัจจัย (MFA)

วิธีการ MFA ที่รองรับ

เปิดใช้งาน TOTP สำหรับการเข้าถึงบัญชี

MFA ในระหว่างการดำเนินการ API

แนวทางปฏิบัติด้านความปลอดภัยที่ดีที่สุด

การจัดการความลับ

ความปลอดภัยในการขนส่ง

การจัดการข้อมูลประจำตัว

การบันทึกและการตรวจสอบ

รูปแบบการยืนยันตัวตนสำหรับองค์กร

การรวม SAML 2.0

การอนุญาตตาม IP

การบันทึกตรวจสอบและความสอดคล้อง

การแก้ไขปัญหาการตรวจสอบสิทธิ์

ข้อผิดพลาดคีย์ API ไม่ถูกต้อง

ข้อผิดพลาดโทเค็นหมดอายุ

ข้อผิดพลาด CORS/Preflight

การท้าทาย MFA ไม่สำเร็จ

เริ่มต้นใช้การตรวจสอบสิทธิ์ที่ปลอดภัยวันนี้

แหล่งข้อมูลที่เกี่ยวข้อง

คู่มือการตรวจสอบสิทธิ์ →

แนวปฏิบัติด้านความปลอดภัยที่ดีที่สุด →

รายการรหัสข้อผิดพลาด →