คู่มือ API SMSCode: เชื่อมต่อเบอร์เสมือนเข้ากับระบบของคุณ

คู่มือ API SMSCode: เชื่อมต่อเบอร์เสมือนเข้ากับระบบของคุณ
SMSCode Team
SMSCode Team
· 10 นาทีในการอ่าน

TL;DR: SMSCode มี RESTful API ที่ใช้งานง่าย ราคาเริ่มต้น ฿0.18 ต่อ SMS รองรับ webhook สำหรับรับข้อความแบบ real-time เหมาะสำหรับนักพัฒนาที่ต้องการรวมระบบยืนยัน OTP เข้ากับแอปพลิเคชัน ตั้งแต่เริ่มต้นจนรัน API call แรกใช้เวลาไม่เกิน 30 นาที

ถ้าคุณเป็นนักพัฒนาและต้องการรวมระบบเบอร์เสมือนเข้ากับแอปหรือระบบของคุณ SMSCode API คือเครื่องมือที่ถูกออกแบบมาเพื่อคุณโดยเฉพาะ บทความนี้จะพาคุณจากศูนย์จนถึงการรัน API call แรกที่ใช้งานได้จริงในเวลาไม่ถึงครึ่งชั่วโมง พร้อม code example ในหลายภาษาและแนวทางปฏิบัติที่ดีที่สุดสำหรับ production

ทำไมนักพัฒนาถึงต้องการ API เบอร์เสมือน

ก่อนลงรายละเอียด มาทำความเข้าใจก่อนว่าทำไม API เบอร์เสมือนจึงเป็นสิ่งจำเป็นสำหรับงานพัฒนาสมัยใหม่

กรณีการใช้งานที่พบบ่อย:

  • การทดสอบระบบ OTP อัตโนมัติ — ทีม QA ต้องการทดสอบ flow การยืนยัน SMS โดยไม่ต้องใช้เบอร์จริงของทีม ซึ่งจะรกและยุ่งยากมากถ้าต้องทดสอบหลายร้อยครั้ง
  • การสร้างบัญชีผู้ใช้จำนวนมากสำหรับทดสอบ — นักพัฒนาต้องการ seed data ที่มีผู้ใช้จริงๆ เพื่อทดสอบ feature ใหม่
  • โปรแกรม scraper หรือ automation ที่ถูกกฎหมาย — ระบบที่ต้องสร้างบัญชีในแพลตฟอร์มต่างๆ โดยอัตโนมัติสำหรับธุรกิจ
  • บริการ multi-account management — แอปที่ช่วยผู้ใช้จัดการหลายบัญชีในแพลตฟอร์มเดียวกัน
  • ระบบ SaaS ที่ต้องการเบอร์โทรศัพท์ — สร้างเบอร์เสมือนให้ผู้ใช้ปลายทางของคุณ

ทำไมต้องใช้ SMSCode API?

มีผู้ให้บริการ API เบอร์เสมือนหลายราย แต่ SMSCode มีจุดเด่นที่ชัดเจน:

  • เบอร์ non-VoIP คุณภาพสูง — ซิมการ์ดจริง ผ่านการตรวจสอบของแพลตฟอร์มใหญ่อย่าง WhatsApp, Telegram, LINE ได้ดีกว่า VoIP
  • ราคาเริ่มต้นต่ำมาก — เพียง ฿0.18 ต่อครั้ง ไม่มีค่าสมาชิกรายเดือน จ่ายตามการใช้งานจริง
  • รองรับ 200+ ประเทศ — เลือกเบอร์ได้หลากหลายตามที่ระบบต้องการ
  • Webhook real-time — รับ SMS ทันทีที่มาถึงโดยไม่ต้อง polling ลดค่าใช้จ่ายและ latency
  • เอกสาร API ครบถ้วน — พร้อม code example หลายภาษา
  • ระบบคืนเงินอัตโนมัติ — ถ้าไม่ได้รับ SMS ภายในเวลาที่กำหนด เงินจะถูกคืนอัตโนมัติ
  • รองรับ PromptPay — เติมเงินสะดวกสำหรับนักพัฒนาไทย

เปรียบเทียบกับคู่แข่งได้ในบทความ SMSCode vs SMS-Activate

ขั้นตอนเริ่มต้น: จากศูนย์ถึง API call แรก

ขั้นที่ 1: สมัครบัญชีและรับ API Key

เข้าไปที่ SMSCode.gg แล้วสมัครบัญชีฟรี ไม่มีค่าใช้จ่ายในการสมัคร

หลังจากยืนยันอีเมลแล้ว:

  1. เข้าสู่ระบบและไปที่ Account → API Settings
  2. กด “Generate API Key”
  3. คัดลอก API key ที่ได้และเก็บไว้อย่างปลอดภัย

สำคัญมาก: API key ของคุณเทียบเท่ารหัสผ่าน ห้ามทำสิ่งเหล่านี้:

  • ห้าม hardcode ใน source code ที่จะ push ขึ้น Git
  • ห้ามใส่ใน .env ที่ไม่ได้ gitignore ไว้
  • ห้าม share ใน Slack, Discord, หรือที่สาธารณะ
  • ห้ามใส่ใน URL parameters

วิธีที่ถูกต้อง: เก็บไว้ใน environment variable เช่น SMSCODE_API_KEY แล้วโหลดจาก .env ที่อยู่ใน .gitignore

ขั้นที่ 2: เติมเงินเข้าบัญชี

API ทำงานบนระบบ prepaid เติมเงินขั้นต่ำ $1 ผ่านช่องทางที่รองรับ:

  • PromptPay (สะดวกสำหรับนักพัฒนาไทย)
  • บัตรเครดิต/เดบิต Visa/Mastercard
  • Cryptocurrency (Bitcoin, Ethereum, USDT)

ดูรายละเอียดช่องทางชำระเงินทั้งหมดในคู่มือการชำระเงิน SMSCode

ขั้นที่ 3: ทดสอบ API แรก

ทดสอบด้วย curl ก่อนเพื่อตรวจสอบว่า key ใช้งานได้และยอดเงินแสดงถูกต้อง:

curl -X GET "https://api.smscode.gg/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY"

ผลลัพธ์ที่คาดหวัง:

{
  "success": true,
  "data": {
    "balance": 1.00,
    "currency": "USD"
  }
}

ถ้าได้ success: true และยอดเงินถูกต้อง แสดงว่า API key ใช้งานได้แล้ว ยินดีด้วย!

API Endpoints หลักและตัวอย่างการใช้งาน

SMSCode API เป็น RESTful API มาตรฐาน ทุก request ต้องมี header Authorization: Bearer YOUR_API_KEY และ response เป็น JSON เสมอ

GET /v1/catalog — ดูบริการและราคา

ใช้ก่อนสั่งเบอร์เพื่อเช็คว่ามีเบอร์ว่างสำหรับ service และ country ที่ต้องการ

curl -X GET "https://api.smscode.gg/v1/catalog" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -G \
  --data-urlencode "service=line" \
  --data-urlencode "country=th"

ผลลัพธ์จะแสดงรายการเบอร์ที่ว่างอยู่ ราคาปัจจุบัน และจำนวนที่เหลืออยู่ ทำให้คุณวางแผนงบประมาณได้ล่วงหน้า

Service codes ที่ใช้บ่อย:

  • line — LINE
  • wa — WhatsApp
  • tg — Telegram
  • google — Google Account
  • fb — Facebook
  • ig — Instagram
  • tt — TikTok
  • shopee — Shopee
  • chatgpt — ChatGPT

Country codes ที่ใช้บ่อยสำหรับนักพัฒนาไทย:

  • th — ไทย
  • id — อินโดนีเซีย
  • my — มาเลเซีย
  • us — สหรัฐอเมริกา
  • gb — สหราชอาณาจักร
  • ru — รัสเซีย

POST /v1/orders — สั่งเบอร์เสมือน

เมื่อเช็ค catalog แล้วพร้อมสั่ง:

curl -X POST "https://api.smscode.gg/v1/orders" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "service": "line",
    "country": "th",
    "operator": "any"
  }'

ผลลัพธ์:

{
  "success": true,
  "data": {
    "order_id": "ord_abc123",
    "phone": "+66812345678",
    "expires_at": "2026-03-16T10:30:00Z",
    "status": "waiting"
  }
}

เก็บ order_id ไว้เพื่อตรวจสอบสถานะภายหลัง เบอร์ที่ได้ (phone) ใช้สมัครบริการได้ทันที

Parameter ที่รองรับ:

  • service (จำเป็น) — service code จาก catalog
  • country (จำเป็น) — country code
  • operator — ผู้ให้บริการเครือข่าย ใช้ "any" ถ้าไม่ต้องการระบุ

GET /v1/orders/{id} — ตรวจสอบสถานะและรับ SMS

curl -X GET "https://api.smscode.gg/v1/orders/ord_abc123" \
  -H "Authorization: Bearer YOUR_API_KEY"

ผลลัพธ์เมื่อ SMS มาถึง:

{
  "success": true,
  "data": {
    "order_id": "ord_abc123",
    "phone": "+66812345678",
    "status": "completed",
    "sms_code": "123456",
    "sms_text": "Your LINE verification code is 123456"
  }
}

สถานะที่เป็นไปได้:

  • waiting — รอรับ SMS
  • completed — ได้รับ SMS แล้ว ดู sms_code และ sms_text
  • cancelled — ถูกยกเลิก
  • expired — หมดเวลา (เงินถูกคืนอัตโนมัติ)
  • refunded — ถูก refund แล้ว

DELETE /v1/orders/{id} — ยกเลิกออเดอร์

curl -X DELETE "https://api.smscode.gg/v1/orders/ord_abc123" \
  -H "Authorization: Bearer YOUR_API_KEY"

ยกเลิกออเดอร์เมื่อไม่ต้องการแล้ว หรือเมื่อรอ SMS นานเกินไปและต้องการลองเบอร์ใหม่ ถ้ายกเลิกก่อนได้รับ SMS เงินจะถูกคืนเข้าบัญชีทันที

ตัวอย่างโค้ดแบบครบวงจร

Python — รอรับ OTP แบบ polling

import requests
import time

API_KEY = "your_api_key_here"
BASE_URL = "https://api.smscode.gg/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def get_virtual_number(service: str, country: str) -> dict:
    """สั่งเบอร์เสมือนและรอรับ OTP"""

    # สั่งเบอร์
    response = requests.post(
        f"{BASE_URL}/orders",
        headers=HEADERS,
        json={"service": service, "country": country}
    )
    response.raise_for_status()
    order = response.json()["data"]
    order_id = order["order_id"]
    phone = order["phone"]

    print(f"เบอร์: {phone}")
    print(f"รอรับ OTP...")

    # รอ OTP (polling ทุก 5 วินาที นาน 5 นาที)
    for attempt in range(60):
        time.sleep(5)
        status_res = requests.get(
            f"{BASE_URL}/orders/{order_id}",
            headers=HEADERS
        )
        status = status_res.json()["data"]

        if status["status"] == "completed":
            print(f"ได้รับ OTP แล้ว: {status['sms_code']}")
            return {
                "phone": phone,
                "code": status["sms_code"],
                "text": status["sms_text"]
            }

        if attempt % 6 == 0:
            print(f"ยังรออยู่... ({attempt * 5} วินาที)")

    # หมดเวลา — ยกเลิกเพื่อรับเงินคืน
    requests.delete(f"{BASE_URL}/orders/{order_id}", headers=HEADERS)
    raise TimeoutError("ไม่ได้รับ OTP ภายใน 5 นาที เงินถูกคืนแล้ว")

# ใช้งาน
result = get_virtual_number("line", "th")
print(f"เบอร์: {result['phone']}")
print(f"OTP: {result['code']}")
print(f"ข้อความเต็ม: {result['text']}")

Node.js / TypeScript — รอรับ OTP พร้อม retry

const API_KEY = process.env.SMSCODE_API_KEY!;
const BASE_URL = "https://api.smscode.gg/v1";

async function getVirtualNumber(service: string, country: string) {
  const headers = {
    Authorization: `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
  };

  // สั่งเบอร์
  const orderRes = await fetch(`${BASE_URL}/orders`, {
    method: "POST",
    headers,
    body: JSON.stringify({ service, country }),
  });

  if (!orderRes.ok) {
    throw new Error(`สั่งเบอร์ไม่สำเร็จ: ${orderRes.status}`);
  }

  const { data: order } = await orderRes.json();
  console.log(`เบอร์: ${order.phone}`);

  // รอ OTP ด้วย polling
  for (let i = 0; i < 60; i++) {
    await new Promise((r) => setTimeout(r, 5000));

    const statusRes = await fetch(`${BASE_URL}/orders/${order.order_id}`, { headers });
    const { data: status } = await statusRes.json();

    if (status.status === "completed") {
      return {
        phone: order.phone,
        code: status.sms_code,
        text: status.sms_text,
      };
    }

    if (status.status === "expired" || status.status === "refunded") {
      throw new Error("ออเดอร์หมดอายุ กรุณาลองสั่งเบอร์ใหม่");
    }
  }

  // หมดเวลา — ยกเลิก
  await fetch(`${BASE_URL}/orders/${order.order_id}`, { method: "DELETE", headers });
  throw new Error("ไม่ได้รับ OTP ภายในเวลาที่กำหนด");
}

// ใช้งาน
const result = await getVirtualNumber("line", "th");
console.log(`OTP: ${result.code}`);

PHP — สำหรับนักพัฒนาเว็บ

<?php

class SMSCodeClient {
    private string $apiKey;
    private string $baseUrl = 'https://api.smscode.gg/v1';

    public function __construct(string $apiKey) {
        $this->apiKey = $apiKey;
    }

    private function request(string $method, string $endpoint, array $data = []): array {
        $ch = curl_init($this->baseUrl . $endpoint);
        $headers = [
            'Authorization: Bearer ' . $this->apiKey,
            'Content-Type: application/json',
        ];

        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);

        if ($data) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }

        $response = curl_exec($ch);
        curl_close($ch);

        return json_decode($response, true);
    }

    public function orderNumber(string $service, string $country): array {
        return $this->request('POST', '/orders', [
            'service' => $service,
            'country' => $country,
        ]);
    }

    public function getOrder(string $orderId): array {
        return $this->request('GET', "/orders/{$orderId}");
    }

    public function cancelOrder(string $orderId): array {
        return $this->request('DELETE', "/orders/{$orderId}");
    }

    public function waitForOtp(string $orderId, int $maxAttempts = 60): ?string {
        for ($i = 0; $i < $maxAttempts; $i++) {
            sleep(5);
            $order = $this->getOrder($orderId);

            if ($order['data']['status'] === 'completed') {
                return $order['data']['sms_code'];
            }
        }

        $this->cancelOrder($orderId);
        return null;
    }
}

// ใช้งาน
$client = new SMSCodeClient($_ENV['SMSCODE_API_KEY']);
$order = $client->orderNumber('line', 'th');
$orderId = $order['data']['order_id'];
$phone = $order['data']['phone'];

echo "เบอร์: {$phone}\n";
$otp = $client->waitForOtp($orderId);

if ($otp) {
    echo "OTP: {$otp}\n";
} else {
    echo "ไม่ได้รับ OTP\n";
}

ตั้งค่า Webhook สำหรับ Production (แนะนำอย่างยิ่ง)

การ polling ทุก 5 วินาทีเป็นวิธีที่ใช้ได้แต่ไม่ efficient สำหรับ production webhook คือทางเลือกที่ดีกว่ามาก เพราะ SMSCode จะส่ง HTTP POST มาหาเซิร์ฟเวอร์ของคุณทันทีที่ SMS มาถึง ทำให้:

  • Latency ต่ำกว่า — ไม่ต้องรอ polling interval
  • ไม่เปลือง API quota — ไม่ต้องส่ง request ซ้ำๆ
  • Scalable มากกว่า — ไม่มีปัญหา concurrency เมื่อต้องรอหลายออเดอร์พร้อมกัน

วิธีตั้งค่า Webhook

  1. ไปที่ Account → API Settings → Webhooks
  2. กรอก URL ของ server ที่จะรับ webhook เช่น https://yourapp.com/webhooks/sms
  3. ระบบจะสร้าง Webhook Secret ให้โดยอัตโนมัติ เก็บไว้ใช้ตรวจสอบ signature
  4. เลือก event ที่ต้องการรับ: sms.received, order.completed, order.expired

Webhook Payload ตัวอย่าง

{
  "event": "sms.received",
  "timestamp": "2026-03-16T10:15:30Z",
  "data": {
    "order_id": "ord_abc123",
    "phone": "+66812345678",
    "service": "line",
    "country": "th",
    "sms_code": "123456",
    "sms_text": "Your LINE verification code is 123456. Do not share this code."
  }
}

Webhook Handler Node.js / Express

import express from "express";
import crypto from "crypto";

const app = express();
app.use(express.json());

// ฟังก์ชันตรวจสอบ webhook signature
function verifySignature(body: string, signature: string, secret: string): boolean {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  return signature === `sha256=${expected}`;
}

app.post("/webhooks/sms", (req, res) => {
  // ดึง raw body สำหรับตรวจสอบ signature
  const rawBody = JSON.stringify(req.body);
  const signature = req.headers["x-smscode-signature"] as string;

  // ตรวจสอบ signature ก่อนเสมอ
  if (!verifySignature(rawBody, signature, process.env.WEBHOOK_SECRET!)) {
    console.error("Webhook signature ไม่ถูกต้อง");
    return res.status(401).json({ error: "Invalid signature" });
  }

  const { event, data } = req.body;

  if (event === "sms.received") {
    const { order_id, phone, sms_code, sms_text, service } = data;

    console.log(`ได้รับ OTP: ${sms_code} สำหรับเบอร์ ${phone} (${service})`);

    // ประมวลผล OTP ของคุณที่นี่
    // เช่น ส่งไปยัง queue, อัปเดต database, หรือเรียก business logic
    processOtp(order_id, sms_code, service);
  }

  // ตอบกลับ 200 ทันทีเพื่อให้ SMSCode รู้ว่ารับ webhook แล้ว
  res.json({ received: true });
});

async function processOtp(orderId: string, otp: string, service: string) {
  // Business logic ของคุณ
  console.log(`กำลังประมวลผล OTP ${otp} สำหรับ ${service} (order: ${orderId})`);
}

Webhook Handler Python / FastAPI

from fastapi import FastAPI, Request, HTTPException
import hmac
import hashlib
import json
import os

app = FastAPI()

def verify_signature(body: bytes, signature: str, secret: str) -> bool:
    expected = hmac.new(
        secret.encode(),
        body,
        hashlib.sha256
    ).hexdigest()
    return signature == f"sha256={expected}"

@app.post("/webhooks/sms")
async def receive_webhook(request: Request):
    body = await request.body()
    signature = request.headers.get("x-smscode-signature", "")
    secret = os.environ["WEBHOOK_SECRET"]

    if not verify_signature(body, signature, secret):
        raise HTTPException(status_code=401, detail="Invalid signature")

    payload = json.loads(body)
    event = payload.get("event")
    data = payload.get("data", {})

    if event == "sms.received":
        order_id = data["order_id"]
        phone = data["phone"]
        sms_code = data["sms_code"]
        service = data["service"]

        print(f"ได้รับ OTP: {sms_code} สำหรับ {phone} ({service})")
        # ประมวลผล OTP ที่นี่

    return {"received": True}

Rate Limits และแนวทางปฏิบัติที่ดี

Rate Limits

ประเภทบัญชีRequests/นาที
มาตรฐาน100
Pro500
Enterprise1,000+ (ติดต่อทีม)

เมื่อเกิน rate limit API จะตอบกลับด้วย HTTP 429 Too Many Requests พร้อม header Retry-After ที่บอกว่าต้องรอกี่วินาที ควรตั้ง retry logic ที่อ่าน header นี้

แนวทางปฏิบัติที่ดีสำหรับ Production

1. ใช้ webhook แทน polling เมื่อเป็นไปได้ polling ทุก 5 วินาทีสำหรับ 10 ออเดอร์พร้อมกัน = 120 requests/นาที ซึ่งใกล้ limit แล้ว webhook ช่วยแก้ปัญหานี้ได้

2. ยกเลิกออเดอร์ที่ไม่ใช้เสมอ ถ้า flow ของคุณสำเร็จหรือล้มเหลวก่อนได้รับ SMS ให้ call DELETE /v1/orders/{id} เพื่อรับเงินคืนทันที

3. ตั้ง timeout ที่เหมาะสม ออเดอร์มีอายุ 20 นาที ตั้ง timeout ของ code ไว้ที่ 18-19 นาที เผื่อเวลาสำหรับ cancellation

4. Handle errors อย่างครบถ้วน ตรวจสอบทุก status code: 400 (bad request), 402 (ยอดเงินไม่พอ), 404 (ออเดอร์ไม่พบ), 429 (rate limit), 503 (server ปัญหา)

5. เก็บ API key ใน environment variables ไม่ hardcode ใน code ไม่เช็คอิน Git ใช้ secrets manager เช่น AWS Secrets Manager หรือ HashiCorp Vault ใน production

6. Log ทุก API call สำหรับ debugging เก็บ order_id, timestamp, service, country และ status ไว้ใน database เพื่อ audit trail

7. ทดสอบใน sandbox ก่อน production ใช้ sandbox mode ใน API settings เพื่อทดสอบโดยไม่หักเงินจริง

Use Cases ที่นักพัฒนาไทยใช้บ่อย

สร้าง Test Accounts อัตโนมัติ

ทีม QA ที่ทดสอบ LINE Bot หรือ Shopee integration บ่อยๆ มักต้องสร้างบัญชีใหม่ทุกครั้ง SMSCode API ช่วยให้ทำ automated test ที่สร้างบัญชีใหม่ ทดสอบ feature แล้ว cleanup ได้ทั้งหมดโดยอัตโนมัติ

ระบบ Signup ที่ต้องการ Unique Phone

SaaS ที่ต้องการให้ผู้ใช้ยืนยันเบอร์โทรแต่ไม่ต้องการ expose เบอร์จริง สามารถออกเบอร์เสมือนให้ผู้ใช้แต่ละคนผ่าน API ได้

Monitoring ระบบ OTP

ใช้ SMSCode API เพื่อ monitor ว่าระบบ OTP ของบริการที่คุณพัฒนาทำงานถูกต้อง โดยสั่งเบอร์ใหม่ทุกชั่วโมงและทดสอบ flow ทั้งหมดโดยอัตโนมัติ

FAQ

ต้องมีความรู้ programming ระดับไหนจึงใช้ API ได้?

ต้องการความรู้พื้นฐาน HTTP REST API สามารถใช้ภาษาใดก็ได้ที่รองรับ HTTP requests เช่น Python, JavaScript/TypeScript, PHP, Go, Ruby, Java, Dart ฯลฯ ถ้ารู้จัก curl พื้นฐาน เริ่มต้นได้เลย

Rate limit ถูก exceeded จะเกิดอะไรขึ้น?

API จะตอบกลับด้วย HTTP 429 Too Many Requests พร้อม header Retry-After ที่บอกว่าต้องรอกี่วินาที ควรเพิ่ม exponential backoff ใน retry logic ของ code

API มี uptime guarantee ไหม?

SMSCode มีเป้าหมาย 99.9% uptime และ load-balanced infrastructure ตรวจสอบสถานะระบบได้ที่ status page ใน dashboard

สามารถทดสอบใน sandbox ก่อนใช้งานจริงได้ไหม?

ใช่ SMSCode มีโหมด sandbox ที่ใช้เครดิตทดสอบโดยไม่หักเงินจริง เปิดใช้งานได้ใน Account → API Settings → Sandbox Mode

ถ้า OTP ไม่มาจะเสียเงินไหม?

ไม่เสียเงินถ้า: (1) ยกเลิกออเดอร์ด้วยตัวเองก่อนหมดเวลา หรือ (2) ออเดอร์หมดอายุเองโดยที่ไม่มี SMS มาถึง ระบบจะคืนเงินอัตโนมัติในทั้งสองกรณี

รองรับภาษา Go, Rust หรือ Dart ไหม?

รองรับทุกภาษาที่ส่ง HTTP request ได้ เนื่องจาก API เป็น standard REST ถ้าต้องการ SDK อย่างเป็นทางการสามารถดูได้ที่ GitHub ของ SMSCode หรือสร้าง wrapper ง่ายๆ เองจาก endpoint ที่อธิบายในบทความนี้

ความแตกต่างระหว่าง polling กับ webhook คืออะไร?

Polling คือการที่โค้ดของคุณถาม SMSCode ซ้ำๆ ทุกไม่กี่วินาที (“มี SMS มาไหม? มาไหม? มาไหม?”) ซึ่งใช้ API quota มาก Webhook คือการที่ SMSCode โทรหาเซิร์ฟเวอร์ของคุณเองทันทีเมื่อ SMS มาถึง เหมาะสำหรับ production มากกว่า

ถ้าต้องการสั่งเบอร์หลายร้อยเบอร์พร้อมกัน ทำได้ไหม?

ได้ แต่ต้องอยู่ภายใน rate limit และมียอดเงินเพียงพอ สำหรับการใช้งานปริมาณมาก แนะนำให้ติดต่อทีม SMSCode เพื่อหารือเรื่อง Enterprise plan ที่มี rate limit สูงขึ้นและราคาพิเศษ

#api#นักพัฒนา#integration#webhook

พร้อมลอง SMSCode แล้วหรือยัง?

สร้างบัญชีแล้วรับเบอร์เสมือนแรกของคุณภายในไม่ถึงสองนาที

เริ่มต้นใช้งาน →