Cara Pakai API SMSCode untuk Otomasi Verifikasi (2026)

Kalau kamu developer yang butuh verifikasi SMS secara otomatis — untuk QA testing, CI/CD pipeline, atau integrasi ke aplikasi — SMSCode menyediakan REST API yang bisa dipanggil langsung dari kode. Beli nomor virtual, tunggu OTP, cancel: semuanya bisa dilakukan programatik dengan response JSON yang konsisten.

Artikel ini adalah tutorial praktis: dari setup autentikasi, tiga endpoint utama yang perlu kamu tahu, sampai contoh kode siap pakai dalam curl, Python, dan JavaScript.

TL;DR: API SMSCode menggunakan Bearer token auth. Endpoint utama: GET /v1/catalog (cek stok dan harga), POST /v1/orders (beli nomor), GET /v1/orders/{id} (polling OTP), DELETE /v1/orders/{id} (cancel), dan GET /v1/balance (cek saldo). Mulai dari Rp 75 per nomor. Daftar gratis, langsung bisa test.

Butuh referensi teknis lebih lengkap? Baca panduan lengkap API SMSCode untuk developer yang mencakup semua detail endpoint.

Siapa yang Butuh API Ini?

API SMSCode cocok untuk beberapa skenario yang sangat umum di kalangan developer Indonesia:

QA dan end-to-end testing. Aplikasi yang punya alur signup dengan verifikasi nomor HP butuh nomor nyata untuk testing. Pakai nomor pribadi di environment production atau staging itu buruk secara praktik. API memungkinkan kamu generate nomor fresh untuk setiap test run.

CI/CD pipeline. Integrasikan verifikasi SMS ke pipeline continuous integration. Setiap push ke main branch bisa memicu test otomatis yang termasuk alur verifikasi nomor HP.

Setup infrastruktur otomatis. Kalau perlu mendaftarkan beberapa akun di layanan tertentu sebagai bagian dari setup sistem (monitoring, testing environment, sandbox), API memungkinkan proses ini berjalan tanpa intervensi manual.

SaaS yang punya fitur verifikasi. Kalau kamu build aplikasi yang menawarkan fitur verifikasi nomor ke pengguna kamu, API SMSCode bisa jadi backend-nya.

Dari pola penggunaan di SMSCode, developer yang menggunakan API rata-rata melakukan 50-200 order per bulan, dengan puncak penggunaan saat sprint QA sebelum release. Use case QA testing dan CI/CD mendominasi penggunaan API dibanding otomasi skala besar.

Setup: Dapatkan API Token

Tidak ada setup yang rumit. Token tersedia langsung setelah kamu punya akun.

Cara dapat token:

Daftar atau login di smscode.gg/auth/signup
Masuk ke dashboard
Buka menu “API” di sidebar
Copy API token kamu

Token ini unik per akun dan bersifat permanen sampai kamu rotasi. Jangan share token ini — siapapun yang punya token bisa menggunakan saldo akun kamu.

Best practice keamanan token:

# Simpan di environment variable, JANGAN di kode
export SMSCODE_API_TOKEN="your_token_here"

Jangan pernah commit token ke repository Git. Gunakan secrets manager seperti GitHub Secrets, AWS Secrets Manager, atau HashiCorp Vault untuk production.

Base URL dan Format Response

Base URL semua endpoint:

https://api.smscode.gg/v1

Format response sukses — konsisten di semua endpoint:

{
  "success": true,
  "data": { ... }
}

Format response error:

{
  "success": false,
  "error": {
    "code": "ERROR_CODE",
    "message": "Deskripsi error"
  }
}

Konsistensi ini memudahkan error handling — cukup cek success field, lalu akses data atau error sesuai hasilnya.

Endpoint 1 — Cek Catalog: Nomor Apa yang Tersedia?

Sebelum beli nomor, kamu perlu tahu layanan dan negara apa yang tersedia beserta harganya.

GET /v1/catalog

Query parameters (semua opsional):

country — kode negara ISO 2 huruf (id = Indonesia, us = Amerika, ru = Rusia)
service — nama platform (whatsapp, instagram, telegram, shopee, dll.)
limit — jumlah hasil per halaman (default: 50)
offset — untuk pagination

Contoh curl

# Cari nomor Indonesia untuk WhatsApp
curl -X GET "https://api.smscode.gg/v1/catalog?service=whatsapp&country=id" \
  -H "Authorization: Bearer $SMSCODE_API_TOKEN"

Contoh response

{
  "success": true,
  "data": {
    "items": [
      {
        "id": "prod_wa_id_001",
        "service": "whatsapp",
        "country": "id",
        "country_name": "Indonesia",
        "price": 350,
        "currency": "IDR",
        "available": true,
        "stock": "high"
      },
      {
        "id": "prod_wa_id_002",
        "service": "whatsapp",
        "country": "id",
        "country_name": "Indonesia",
        "price": 300,
        "currency": "IDR",
        "available": true,
        "stock": "medium"
      }
    ],
    "total": 2
  }
}

Field stock bisa berupa high, medium, atau low — pilih yang high untuk keandalan terbaik.

Contoh Python

import requests
import os

API_TOKEN = os.environ["SMSCODE_API_TOKEN"]
BASE_URL = "https://api.smscode.gg/v1"
HEADERS = {"Authorization": f"Bearer {API_TOKEN}"}

def get_catalog(service=None, country=None):
    params = {}
    if service:
        params["service"] = service
    if country:
        params["country"] = country

    resp = requests.get(f"{BASE_URL}/catalog", headers=HEADERS, params=params)
    resp.raise_for_status()
    return resp.json()["data"]["items"]

# Cari nomor WhatsApp dari Indonesia
items = get_catalog(service="whatsapp", country="id")
for item in items:
    print(f"ID: {item['id']} | Harga: Rp {item['price']} | Stok: {item['stock']}")

Contoh JavaScript (Node.js)

const axios = require('axios');

const API_TOKEN = process.env.SMSCODE_API_TOKEN;
const BASE_URL = 'https://api.smscode.gg/v1';
const headers = { Authorization: `Bearer ${API_TOKEN}` };

async function getCatalog(service, country) {
  const params = {};
  if (service) params.service = service;
  if (country) params.country = country;

  const resp = await axios.get(`${BASE_URL}/catalog`, { headers, params });
  return resp.data.data.items;
}

// Contoh penggunaan
(async () => {
  const items = await getCatalog('whatsapp', 'id');
  items.forEach(item => {
    console.log(`ID: ${item.id} | Harga: Rp ${item.price} | Stok: ${item.stock}`);
  });
})();

Endpoint 2 — Buat Order: Beli Nomor Virtual

Setelah dapat product_id dari catalog, buat order untuk mendapatkan nomor virtual.

POST /v1/orders

Request body (JSON):

{
  "product_id": "prod_wa_id_001"
}

Contoh curl

curl -X POST "https://api.smscode.gg/v1/orders" \
  -H "Authorization: Bearer $SMSCODE_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"product_id": "prod_wa_id_001"}'

Contoh response (order berhasil)

{
  "success": true,
  "data": {
    "order_id": "ord_abc123",
    "phone_number": "+6281234567890",
    "country": "id",
    "service": "whatsapp",
    "status": "pending",
    "price": 350,
    "currency": "IDR",
    "expires_at": "2026-03-16T10:35:00Z"
  }
}

Simpan order_id — kamu butuh ini untuk polling OTP dan cancel.

Contoh Python

def create_order(product_id):
    resp = requests.post(
        f"{BASE_URL}/orders",
        headers={**HEADERS, "Content-Type": "application/json"},
        json={"product_id": product_id}
    )
    resp.raise_for_status()
    return resp.json()["data"]

# Beli nomor Indonesia untuk WhatsApp
items = get_catalog(service="whatsapp", country="id")
# Pilih yang stoknya tinggi dan harga paling murah
best = min(
    [i for i in items if i["stock"] in ("high", "medium")],
    key=lambda x: x["price"]
)
order = create_order(best["id"])
print(f"Nomor: {order['phone_number']}")
print(f"Order ID: {order['order_id']}")
print(f"Expired: {order['expires_at']}")

Contoh JavaScript

async function createOrder(productId) {
  const resp = await axios.post(
    `${BASE_URL}/orders`,
    { product_id: productId },
    { headers: { ...headers, 'Content-Type': 'application/json' } }
  );
  return resp.data.data;
}

Endpoint 3 — Polling OTP: Tunggu SMS Masuk

Setelah memasukkan nomor virtual ke layanan target dan meminta OTP, kamu perlu polling status order untuk menunggu SMS masuk.

GET /v1/orders/{order_id}

Status yang Mungkin

Status	Artinya
`pending`	Order aktif, belum ada OTP
`completed`	OTP sudah masuk (lihat `sms_code`)
`cancelled`	Order dibatalkan (saldo dikembalikan)
`expired`	Waktu habis tanpa OTP (saldo dikembalikan)

Contoh curl

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

Contoh response (OTP masuk)

{
  "success": true,
  "data": {
    "order_id": "ord_abc123",
    "phone_number": "+6281234567890",
    "status": "completed",
    "sms_code": "847293",
    "sms_text": "WhatsApp code 847293. You can also tap on this link to verify...",
    "received_at": "2026-03-16T10:32:45Z",
    "expires_at": "2026-03-16T10:35:00Z"
  }
}

Implementasi Polling Python (Lengkap)

import time

def poll_for_otp(order_id, timeout=120, interval=5):
    """
    Poll status order sampai OTP masuk atau timeout.

    Args:
        order_id: ID order yang dipoll
        timeout: Maksimum detik tunggu (default 120)
        interval: Interval polling dalam detik (default 5)

    Returns:
        str: SMS code kalau berhasil
        None: kalau timeout atau order gagal
    """
    deadline = time.time() + timeout

    while time.time() < deadline:
        resp = requests.get(
            f"{BASE_URL}/orders/{order_id}",
            headers=HEADERS
        )
        resp.raise_for_status()
        data = resp.json()["data"]

        if data["status"] == "completed":
            return data["sms_code"]
        elif data["status"] in ("cancelled", "expired"):
            print(f"Order {order_id} berakhir dengan status: {data['status']}")
            return None

        # Masih pending — tunggu
        time.sleep(interval)

    print(f"Timeout setelah {timeout} detik")
    return None

Implementasi Polling JavaScript

async function pollForOtp(orderId, timeout = 120000, interval = 5000) {
  const deadline = Date.now() + timeout;

  while (Date.now() < deadline) {
    const resp = await axios.get(`${BASE_URL}/orders/${orderId}`, { headers });
    const data = resp.data.data;

    if (data.status === 'completed') return data.sms_code;
    if (['cancelled', 'expired'].includes(data.status)) return null;

    // Masih pending — tunggu sebentar
    await new Promise(r => setTimeout(r, interval));
  }

  return null; // Timeout
}

Best practice polling:

Interval 5 detik sudah cukup — jangan polling lebih agresif dari itu
OTP biasanya masuk dalam 15-90 detik setelah nomor dimasukkan ke layanan target
Set timeout sesuai batas aktif nomor (~20 menit), tapi 2-3 menit biasanya cukup

Endpoint 4 — Cancel Order

Kalau nomor tidak diperlukan lagi atau mau ganti ke negara lain, cancel order untuk mendapatkan saldo kembali.

DELETE /v1/orders/{order_id}

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

Order hanya bisa di-cancel saat status masih pending dan belum ada OTP masuk.

def cancel_order(order_id):
    resp = requests.delete(
        f"{BASE_URL}/orders/{order_id}",
        headers=HEADERS
    )
    resp.raise_for_status()
    return resp.json()

Endpoint 5 — Cek Saldo

Pastikan ada cukup saldo sebelum membuat order — terutama penting untuk automation supaya tidak ada order yang gagal karena saldo habis.

GET /v1/balance

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

{
  "success": true,
  "data": {
    "balance": 45250,
    "currency": "IDR"
  }
}

def get_balance():
    resp = requests.get(f"{BASE_URL}/balance", headers=HEADERS)
    resp.raise_for_status()
    return resp.json()["data"]["balance"]

# Cek sebelum order
balance = get_balance()
if balance < 500:  # threshold minimal
    raise Exception(f"Saldo tidak cukup: Rp {balance}")

Contoh Lengkap: Alur Verifikasi Penuh

Berikut contoh alur lengkap dari cek catalog sampai dapat OTP — siap dipakai sebagai template:

Python — Alur Lengkap

import requests
import time
import os

API_TOKEN = os.environ["SMSCODE_API_TOKEN"]
BASE_URL = "https://api.smscode.gg/v1"
HEADERS = {"Authorization": f"Bearer {API_TOKEN}"}


def get_best_product(service, country, max_price=None):
    """Cari produk terbaik berdasarkan stok dan harga."""
    params = {"service": service, "country": country}
    resp = requests.get(f"{BASE_URL}/catalog", headers=HEADERS, params=params)
    resp.raise_for_status()
    items = resp.json()["data"]["items"]

    # Filter stok tersedia
    available = [i for i in items if i["available"] and i["stock"] != "low"]
    if max_price:
        available = [i for i in available if i["price"] <= max_price]

    if not available:
        return None

    # Urutkan: high stock dulu, lalu harga termurah
    stock_priority = {"high": 0, "medium": 1, "low": 2}
    available.sort(key=lambda x: (stock_priority.get(x["stock"], 3), x["price"]))
    return available[0]


def verify_with_sms(service, country, submit_number_fn, max_price=None):
    """
    Alur verifikasi lengkap.

    Args:
        service: Nama layanan (misal 'whatsapp')
        country: Kode negara (misal 'id')
        submit_number_fn: Fungsi yang menerima phone_number dan submit ke layanan target
        max_price: Batas harga maksimal (opsional)

    Returns:
        str: OTP code kalau berhasil, None kalau gagal
    """
    # 1. Cek saldo
    balance_resp = requests.get(f"{BASE_URL}/balance", headers=HEADERS)
    balance = balance_resp.json()["data"]["balance"]
    print(f"Saldo: Rp {balance}")

    # 2. Cari produk
    product = get_best_product(service, country, max_price)
    if not product:
        print("Tidak ada nomor tersedia")
        return None

    print(f"Produk: {product['id']} | Harga: Rp {product['price']} | Stok: {product['stock']}")

    # 3. Cek saldo cukup
    if balance < product["price"]:
        print("Saldo tidak cukup")
        return None

    # 4. Buat order
    order_resp = requests.post(
        f"{BASE_URL}/orders",
        headers={**HEADERS, "Content-Type": "application/json"},
        json={"product_id": product["id"]}
    )
    order_resp.raise_for_status()
    order = order_resp.json()["data"]
    order_id = order["order_id"]
    phone = order["phone_number"]
    print(f"Nomor: {phone} | Order: {order_id}")

    try:
        # 5. Submit nomor ke layanan target
        submit_number_fn(phone)

        # 6. Poll untuk OTP
        deadline = time.time() + 120
        while time.time() < deadline:
            poll_resp = requests.get(
                f"{BASE_URL}/orders/{order_id}",
                headers=HEADERS
            )
            data = poll_resp.json()["data"]

            if data["status"] == "completed":
                print(f"OTP: {data['sms_code']}")
                return data["sms_code"]
            elif data["status"] in ("cancelled", "expired"):
                return None

            time.sleep(5)

        print("Timeout — order expired, saldo dikembalikan")
        return None

    except Exception as e:
        # Cancel order jika ada error di submit
        requests.delete(f"{BASE_URL}/orders/{order_id}", headers=HEADERS)
        raise e


# Contoh penggunaan
def my_app_submit_number(phone):
    """
    Implementasi submit nomor ke aplikasi target kamu.
    Contoh: pakai Playwright, requests, atau SDK layanan target.
    """
    print(f"Submitting number {phone} to target service...")
    # page.fill('#phone-input', phone)
    # page.click('#send-otp-btn')
    pass


otp = verify_with_sms(
    service="whatsapp",
    country="id",
    submit_number_fn=my_app_submit_number,
    max_price=500
)

JavaScript (Node.js) — Alur Lengkap

const axios = require('axios');

const API_TOKEN = process.env.SMSCODE_API_TOKEN;
const BASE_URL = 'https://api.smscode.gg/v1';
const headers = { Authorization: `Bearer ${API_TOKEN}` };

async function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function verifyWithSms({ service, country, submitNumberFn, maxPrice = null }) {
  // 1. Cek catalog
  const catalogResp = await axios.get(`${BASE_URL}/catalog`, {
    headers,
    params: { service, country }
  });
  let items = catalogResp.data.data.items.filter(
    i => i.available && i.stock !== 'low'
  );
  if (maxPrice) items = items.filter(i => i.price <= maxPrice);
  if (!items.length) throw new Error('Tidak ada nomor tersedia');

  // Pilih terbaik
  const stockRank = { high: 0, medium: 1, low: 2 };
  items.sort((a, b) =>
    stockRank[a.stock] - stockRank[b.stock] || a.price - b.price
  );
  const product = items[0];

  // 2. Buat order
  const orderResp = await axios.post(
    `${BASE_URL}/orders`,
    { product_id: product.id },
    { headers: { ...headers, 'Content-Type': 'application/json' } }
  );
  const order = orderResp.data.data;
  const { order_id: orderId, phone_number: phone } = order;
  console.log(`Nomor: ${phone} | Order: ${orderId}`);

  try {
    // 3. Submit nomor ke layanan target
    await submitNumberFn(phone);

    // 4. Polling
    const deadline = Date.now() + 120_000;
    while (Date.now() < deadline) {
      const pollResp = await axios.get(`${BASE_URL}/orders/${orderId}`, { headers });
      const data = pollResp.data.data;

      if (data.status === 'completed') {
        console.log(`OTP: ${data.sms_code}`);
        return data.sms_code;
      }
      if (['cancelled', 'expired'].includes(data.status)) return null;

      await sleep(5000);
    }
    return null;

  } catch (err) {
    // Cancel kalau ada error
    await axios.delete(`${BASE_URL}/orders/${orderId}`, { headers }).catch(() => {});
    throw err;
  }
}

// Contoh penggunaan
(async () => {
  const otp = await verifyWithSms({
    service: 'instagram',
    country: 'us',
    submitNumberFn: async (phone) => {
      console.log(`Submit ${phone} ke Instagram...`);
      // await page.fill('#phone', phone);
      // await page.click('#send-otp');
    },
    maxPrice: 500
  });
  console.log('OTP diterima:', otp);
})();

Rate Limits

SMSCode API punya rate limit untuk mencegah penyalahgunaan:

Endpoint	Limit
`GET /v1/catalog`	60 request/menit
`POST /v1/orders`	20 order/menit
`GET /v1/orders/{id}`	120 request/menit
`DELETE /v1/orders/{id}`	20 request/menit
`GET /v1/balance`	60 request/menit

Kalau melewati limit, API return 429 Too Many Requests dengan header Retry-After yang menunjukkan berapa detik harus menunggu.

import time

def safe_request(fn, *args, **kwargs):
    """Wrapper request dengan handling rate limit."""
    while True:
        try:
            return fn(*args, **kwargs)
        except requests.exceptions.HTTPError as e:
            if e.response.status_code == 429:
                retry_after = int(e.response.headers.get("Retry-After", 60))
                print(f"Rate limited. Tunggu {retry_after} detik...")
                time.sleep(retry_after)
            else:
                raise

Error Codes yang Perlu Diketahui

HTTP Status	Kode	Arti
401	`UNAUTHORIZED`	Token tidak valid atau tidak ada
402	`INSUFFICIENT_BALANCE`	Saldo tidak cukup
404	`NOT_FOUND`	Order atau produk tidak ditemukan
409	`ALREADY_CANCELLED`	Order sudah di-cancel sebelumnya
422	`INVALID_REQUEST`	Parameter request tidak valid
429	`RATE_LIMITED`	Terlalu banyak request
500	`SERVER_ERROR`	Error di sisi server

def handle_api_error(e):
    """Handler error API yang informatif."""
    if not hasattr(e, 'response') or e.response is None:
        print(f"Network error: {e}")
        return

    status = e.response.status_code
    try:
        error = e.response.json()["error"]
        code = error.get("code", "UNKNOWN")
        msg = error.get("message", "")
    except Exception:
        code, msg = "PARSE_ERROR", e.response.text

    if status == 402:
        print("Saldo tidak cukup. Top up dulu di smscode.gg/deposit")
    elif status == 429:
        retry = int(e.response.headers.get("Retry-After", 60))
        print(f"Rate limited. Tunggu {retry} detik.")
    elif status == 500:
        print("Server error. Coba lagi dalam beberapa saat.")
    else:
        print(f"API Error [{code}]: {msg}")

Tips untuk Production

Simpan log setiap order. Catat order_id, phone_number, service, country, status akhir, dan OTP (kalau berhasil). Ini berguna untuk debugging, rekonsiliasi saldo, dan audit.

import logging
import json

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("smscode")

def log_order(order, status, otp=None):
    logger.info(json.dumps({
        "order_id": order["order_id"],
        "phone": order["phone_number"],
        "service": order["service"],
        "country": order["country"],
        "price": order["price"],
        "status": status,
        "otp": otp
    }))

Monitor saldo secara berkala. Jangan biarkan saldo habis di tengah proses automation. Tambahkan check saldo sebelum setiap batch order, atau buat alerting kalau saldo di bawah threshold.

Implement retry dengan backoff. Kalau order gagal karena error sementara, jangan langsung retry — tunggu beberapa detik dengan exponential backoff.

Dari pengalaman developer yang integrasikan SMSCode ke pipeline CI/CD, pattern yang paling robust adalah: cek saldo → cek catalog (pilih stok high) → buat order → submit ke layanan target dalam 5 detik → poll selama 2 menit. Kalau gagal, cancel, pilih negara lain, coba lagi maksimal 3 kali sebelum throw error ke CI.

Integrasi dengan Testing Framework

Pytest Fixture (Python)

# conftest.py
import pytest
import requests
import time
import os

SMSCODE_TOKEN = os.environ["SMSCODE_API_TOKEN"]
BASE = "https://api.smscode.gg/v1"
HDRS = {"Authorization": f"Bearer {SMSCODE_TOKEN}"}

@pytest.fixture
def sms_verifier():
    """Fixture untuk verifikasi SMS di test."""
    orders = []

    def buy_number(service, country="id"):
        # Cek catalog
        items = requests.get(f"{BASE}/catalog", headers=HDRS,
                             params={"service": service, "country": country}).json()["data"]["items"]
        available = [i for i in items if i["available"]]
        if not available:
            pytest.skip(f"Tidak ada nomor {service} dari {country}")

        # Order
        order = requests.post(f"{BASE}/orders", headers=HDRS,
                              json={"product_id": available[0]["id"]}).json()["data"]
        orders.append(order["order_id"])
        return order["phone_number"], order["order_id"]

    def get_otp(order_id, timeout=90):
        for _ in range(timeout // 5):
            data = requests.get(f"{BASE}/orders/{order_id}", headers=HDRS).json()["data"]
            if data["status"] == "completed":
                return data["sms_code"]
            if data["status"] in ("cancelled", "expired"):
                return None
            time.sleep(5)
        return None

    yield buy_number, get_otp

    # Cleanup — cancel order yang masih pending
    for oid in orders:
        try:
            requests.delete(f"{BASE}/orders/{oid}", headers=HDRS)
        except Exception:
            pass


# test_signup.py
def test_signup_flow(sms_verifier):
    buy_number, get_otp = sms_verifier
    phone, order_id = buy_number("whatsapp", "id")

    # Submit nomor ke aplikasi kamu
    # result = your_app.request_otp(phone)

    otp = get_otp(order_id)
    assert otp is not None, "OTP tidak masuk dalam batas waktu"
    assert len(otp) >= 4

    # Verifikasi OTP
    # assert your_app.verify_otp(otp)

FAQ

Apakah API tersedia 24/7?

Ya, API SMSCode beroperasi 24/7. Ketersediaan nomor tergantung stok dari provider — beberapa layanan atau negara mungkin kehabisan stok di waktu tertentu. Selalu cek available: true dan stock di catalog sebelum order.

Bagaimana kalau OTP tidak masuk — apakah saldo hilang?

Tidak. Kalau order expired tanpa OTP masuk, saldo otomatis dikembalikan penuh. Kamu tinggal cancel (atau tunggu expire) dan coba lagi dengan produk atau negara berbeda.

Berapa lama order aktif sebelum expire?

Nomor aktif selama sekitar 20 menit sejak order dibuat. Selama periode itu, nomor bisa menerima SMS berkali-kali. Setelah expire, order otomatis tutup dan saldo dikembalikan kalau OTP belum pernah masuk.

Apakah ada SDK resmi untuk Python atau JavaScript?

Belum ada SDK resmi saat ini. API-nya adalah REST standar yang bisa dipanggil dari bahasa manapun. Contoh kode di artikel ini adalah starting point yang sudah production-ready — kamu tinggal wrap sesuai kebutuhan aplikasi.

Apakah bisa pakai webhook instead of polling?

Cek dokumentasi terbaru di dashboard SMSCode — opsi webhook mungkin sudah tersedia. Kalau belum, polling dengan interval 5 detik adalah pendekatan standar yang tidak membebani rate limit.

Siap integrasi? Daftar gratis di SMSCode, top up minimum Rp 10.000, dan test API dengan curl atau kode di atas. Baca panduan API lengkap untuk referensi endpoint yang lebih detail, atau cek halaman pricing untuk rate per layanan.