เอกสาร

ทุกสิ่งที่คุณต้องใช้เพื่อเชื่อมต่อ SublimeKeys เข้ากับแอปของคุณ ไม่ต้องมีบัญชีก็อ่านได้

$SUBLIMEKEYS_API_KEY

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

เริ่มต้นอย่างรวดเร็ว — 3 การเรียก

1. ลงทะเบียนผลิตภัณฑ์ของคุณ (ทำครั้งเดียว ในหน้าผลิตภัณฑ์)

curl -X POST https://api.sublimearts.io/v1/products \
  -H "Authorization: Bearer $SUBLIMEKEYS_API_KEY" \
  -d '{"slug":"my-app","key_prefix":"MYAPP"}'

2. ออกคีย์ทุกครั้งที่มีการขาย

curl -X POST https://api.sublimearts.io/v1/licenses \
  -H "Authorization: Bearer $SUBLIMEKEYS_API_KEY" \
  -d '{"product":"my-app","email":"buyer@mail.com","max_activations":3}'

→ {"key":"MYAPP-K3F7Q-9WZ2M-P8RT4-XN5CB", ...}
productจำเป็น — slug ของผลิตภัณฑ์จากขั้นตอนที่ 1
emailไม่บังคับ — แสดงในรายการไลเซนส์บนแดชบอร์ดของคุณ
max_activationsไม่บังคับ ค่าเริ่มต้นคือ 1 — คีย์ตัวเดียวนี้เปิดใช้งานได้พร้อมกันบน machine_id ที่ต่างกันกี่เครื่อง ตั้งค่าตามที่ราคาของคุณเองสัญญาไว้ (เช่น 3 สำหรับแพ็กเกจ "ใช้ส่วนตัว 3 เครื่อง") มีเพดานตามแพ็กเกจ SublimeKeys ของคุณเอง ไม่ใช่ของลูกค้าปลายทาง — 5 สำหรับ Free, 25 สำหรับ Pro, 100 สำหรับ Business (ดูราคา)
expires_atไม่บังคับ — วันที่แบบ ISO ละไว้เพื่อให้เป็นคีย์ตลอดชีพ
notesไม่บังคับ — ข้อความอิสระ สำหรับอ้างอิงส่วนตัวของคุณเท่านั้น

หรือข้ามการเรียกนี้ไปเลยก็ได้ — ดู AUTOMATE ด้านล่าง

3. ตรวจสอบภายในแอปของคุณ

Python — SDK อย่างเป็นทางการ (แนะนำ)
# pip install sublimekeys
from sublimekeys import SublimeKeysClient

client = SublimeKeysClient(product_id="my-app")
result = client.activate(license_key=key)   # first run
result = client.verify(license_key=key)     # every launch after — offline-first,
                                             # verifies a signed lease locally,
                                             # zero network calls for up to 7 days
if result.valid:
    unlock_full_version()
Node.js / Electron — SDK อย่างเป็นทางการ (แนะนำ)
// npm install sublimekeys
import { SublimeKeysClient } from "sublimekeys";

const client = new SublimeKeysClient("my-app");
const activated = await client.activate(key);     // first run
const result = await client.verify(key);          // every launch after — offline-first,
                                                   // verifies a signed lease locally,
                                                   // zero network calls for up to 7 days
if (result.valid) unlockFullVersion();

ไม่ได้ใช้ Python หรือ Node.js หรืออยากเรียก API แบบดิบด้วยตัวเอง? Python SDK บน PyPI · Node.js SDK บน npm หรือใช้ endpoint ด้านล่างนี้โดยตรง

Python — raw API
import requests

r = requests.post("https://api.sublimearts.io/activate", json={
    "license_key": key,
    "machine_id": machine_id,
    "product_id": "my-app",
})
if r.json()["valid"]:
    unlock_full_version()
Node.js — raw API
const r = await fetch("https://api.sublimearts.io/activate", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ license_key, machine_id, product_id: "my-app" }),
});
const { valid } = await r.json();
if (valid) unlockFullVersion();
cURL
curl -X POST https://api.sublimearts.io/activate \
  -d '{"license_key":"...","machine_id":"...","product_id":"my-app"}'
▸ เพิ่งเคยเจอสิ่งนี้? การเรียกเหล่านี้อยู่ตรงไหนในแอปของคุณจริง ๆ

ตัวอย่างด้านบนแสดงแค่ /activate เดี่ยว ๆ เท่านั้น — ในแอปจริงคุณจะเรียก endpoint ต่าง ๆ กันในแต่ละช่วงเวลา:

แอปเริ่มทำงาน
├─ ยังไม่มีไลเซนส์คีย์ที่บันทึกไว้ (รันครั้งแรก)
│    → แสดงหน้าจอ "กรอกไลเซนส์คีย์" ของคุณ
│    → ผู้ใช้ส่งคีย์ → เรียก /activate หนึ่งครั้ง → บันทึกผลลัพธ์ไว้ในเครื่อง
│
├─ มีไลเซนส์คีย์บันทึกไว้แล้ว (การเปิดใช้งานครั้งต่อ ๆ ไป)
│    → เรียก /verify แทน (ไม่ใช่ /activate อีกครั้ง) — ยืนยันว่ายัง
│      ใช้ได้บนเครื่องนี้
│
├─ เข้าถึง API ไม่ได้ (ผู้ใช้ออฟไลน์)
│    → ทั้ง /activate และ /verify คืนค่า "lease" ที่เซ็นรับรอง (ใช้ได้ 7 วัน)
│    → ตรวจสอบลายเซ็นในเครื่องแทนที่จะเชื่อผลลัพธ์ล่าสุดแบบไม่ตรวจสอบ
│      — SDK ของ Python และ Node.js ทำสิ่งนี้ให้อัตโนมัติ ส่วนภาษาอื่น
│      สามารถตรวจสอบลายเซ็น Ed25519 ได้เอง (public key
│      อยู่ที่ GET /public-key)
│
└─ ผู้ใช้ถอนการติดตั้ง/ออกจากระบบ (ไม่บังคับ)
     → เรียก /deactivate เพื่อปลดโควตาให้เครื่องอื่นใช้

บน Python หรือ Node.js/Electron, SDK อย่างเป็นทางการ (PyPI · npm) จัดการเรื่องนี้ให้แล้ว — รวมถึงการตรวจสอบเข้ารหัสจริงของ lease แบบออฟไลน์ เวอร์ชัน raw ด้านล่างข้ามขั้นตอนนั้นไป (แค่เชื่อผลลัพธ์ล่าสุดที่บันทึกไว้ตอนออฟไลน์) — ง่ายกว่าแต่ไม่ได้ตรวจสอบด้วยการเข้ารหัส ใช้มันถ้าคุณไม่ได้ใช้ Python/Node.js หรือต้องการควบคุมเต็มรูปแบบ

Python — ขั้นตอนการเริ่มแอปแบบเต็ม (raw API ไม่ใช้ SDK)
import requests, json, os

STATE_FILE = "license_state.json"

def check_license(machine_id):
    saved = json.load(open(STATE_FILE)) if os.path.exists(STATE_FILE) else None

    try:
        if saved is None:
            # first run — ask the user for their key once
            key = prompt_for_license_key()
            r = requests.post("https://api.sublimearts.io/activate", json={
                "license_key": key, "machine_id": machine_id, "product_id": "my-app",
            }, timeout=5)
        else:
            # every later launch — re-check the saved key, don't ask again
            r = requests.post("https://api.sublimearts.io/verify", json={
                "license_key": saved["license_key"], "machine_id": machine_id, "product_id": "my-app",
            }, timeout=5)

        result = r.json()
        json.dump(result, open(STATE_FILE, "w"))
        return result["valid"]

    except requests.RequestException:
        # offline — trust the last known result instead of locking the user out
        return saved["valid"] if saved else False

คุ้นเคยกับแนวคิดนี้แล้วใช่ไหม? ข้ามส่วนนี้ไปได้เลย — การเรียกด้านบนคือทั้งหมดที่คุณต้องใช้

SDK อย่างเป็นทางการ

🐍 Python — sublimekeys

ห่อ API ทั้งหมดไว้และจัดการการตรวจสอบแบบออฟไลน์ให้คุณ — activate/verify/deactivate ด้วย lease ที่เซ็นรับรองซึ่งตรวจสอบในเครื่อง ทำให้การเปิดใช้งานส่วนใหญ่ไม่ต้องเรียกเครือข่ายเลย พร้อมการตรวจสอบทดลองใช้ที่รอดพ้นช่วงออฟไลน์ได้เช่นกัน นอกจากนี้ยังติดตั้ง CLI sublimekeys สำหรับทดสอบการผสานระบบจากเทอร์มินัล

pip install sublimekeys
ดูบน PyPI →

⚡ Node.js / Electron — sublimekeys

ออกแบบให้รองรับออฟไลน์เช่นเดียวกัน ไม่มี dependency ตอนรันไทม์เลย — การตรวจสอบ Ed25519 ใช้ crypto ในตัวของ Node จึงไม่มีอะไรให้การแพ็กเกจ asar ของ Electron สะดุด

npm install sublimekeys
ดูบน npm →

ภาษาอื่น ๆ อยู่ในแผนงานอนาคต ระหว่างนี้ endpoint ทุกตัวด้านล่างเป็นการเรียก REST ธรรมดา — เรียกได้จากทุกอย่างที่ส่งคำขอ HTTPS ได้

รายการอ้างอิง ENDPOINT — สาธารณะ (เรียกโดยแอปของคุณ)

POST /activate

body: { "license_key", "machine_id", "product_id" }

▸ รายละเอียด

การรันครั้งแรก — ผูกไลเซนส์คีย์เข้ากับ machine_id ปลอดภัยที่จะเรียกซ้ำบนเครื่องเดียวกัน — จะไม่กินโควตาการเปิดใช้งานเพิ่ม จะคืนค่า valid:false พร้อมข้อความหากทำไม่ได้ (เช่น ถึงขีดจำกัดการเปิดใช้งานบนเครื่องอื่นแล้ว) เมื่อสำเร็จ จะคืนค่า lease ที่เซ็นรับรอง (ช่วงความน่าเชื่อถือออฟไลน์ 7 วัน) ในฟิลด์ lease ของการตอบกลับด้วย — Python SDK จะตรวจสอบสิ่งนี้ในเครื่องสำหรับการเปิดครั้งต่อ ๆ ไป แทนที่จะเรียก API ทุกครั้ง

POST /verify

body: { "license_key", "machine_id", "product_id" }

▸ รายละเอียด

ทุกการเปิดใช้งานครั้งต่อไป — ยืนยันว่าคีย์ยังใช้ได้บนเครื่องนี้ ไม่กระทบจำนวนการเปิดใช้งานของคุณ จึงเรียกได้บ่อยเท่าที่ต้องการ และยังต่ออายุ lease ที่เซ็นรับรอง (ดู /activate) ทุกครั้งที่เรียกสำเร็จด้วย

POST /deactivate

body: { "license_key", "machine_id", "product_id" }

▸ รายละเอียด

ผู้ใช้ออกจากระบบ/ถอนการติดตั้ง — ปลดโควตาให้เครื่องอื่นใช้

POST /trial/start

body: { "machine_id", "product_id" }

▸ รายละเอียด

รับหรือสร้างช่วงทดลองใช้ 7 วันสำหรับเครื่องหนึ่ง ๆ เป็นแบบ idempotent — การติดตั้งใหม่จะไม่รีเซ็ตเวลานับถอยหลังเลย

POST /trial/status

body: { "machine_id", "product_id" }

▸ รายละเอียด

ตรวจสอบสถานะทดลองใช้แบบอ่านอย่างเดียว — จะไม่เริ่มช่วงทดลองใช้ใหม่เลย

ไม่มี header Authorization สำหรับสิ่งเหล่านี้ — license_key เองคือข้อมูลรับรอง API แบบเต็มระดับบัญชี (create/list/revoke) อยู่ภายใต้ /v1/* ดูได้ที่แดชบอร์ด

⚡ AUTOMATE — ส่งมอบคีย์โดยไม่ต้องมีแบ็กเอนด์

ข้ามขั้นตอนที่ 2 ด้านบนไปได้เลย ตั้งค่า webhook ของผู้ให้บริการชำระเงินของคุณไปที่ URL ของผลิตภัณฑ์ แล้วทุกการขายจะออกคีย์และส่งอีเมลให้ผู้ซื้อโดยอัตโนมัติ

  1. Stripe Dashboard → Developers → Webhooks → Add endpoint
  2. วาง URL ของผลิตภัณฑ์คุณ (เข้าสู่ระบบและสร้างผลิตภัณฑ์เพื่อรับ URL ของคุณ)
  3. เลือกอีเวนต์: checkout.session.completed
  4. บันทึก แค่นี้เลย — ไม่ต้องมีเซิร์ฟเวอร์ ไม่ต้องเขียนโค้ด
  5. ไม่บังคับแต่แนะนำ: Stripe จะแสดง Signing secret ทันทีหลังจากนั้น — วางมันลงใน "Signature verification" ที่หน้าผลิตภัณฑ์ เพื่อให้เราปฏิเสธทุกอย่างที่ไม่ได้มาจาก Stripe จริง ๆ (ไม่ใช่แค่ใครก็ตามที่มี URL นี้)

🔔 อยากได้รับอีเมลเองทุกครั้งที่มีการขายด้วยไหม? เปิด "Notify me" ข้าง ๆ บล็อกนี้ที่หน้าผลิตภัณฑ์

ย้ายข้อมูลจาก GUMROAD, KEYGEN หรือเซิร์ฟเวอร์ของคุณเอง

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

migrate.py
import csv, os, requests

API_KEY = os.environ["SUBLIMEKEYS_API_KEY"]
PRODUCT = "my-app"

with open("customers.csv") as f:
    for row in csv.DictReader(f):
        r = requests.post("https://api.sublimearts.io/v1/licenses",
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={"product": PRODUCT, "email": row["email"]})
        print(row["email"], "->", r.json()["key"])

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

ขีดจำกัดของแพ็กเกจ

FREE

1 ผลิตภัณฑ์ · 100 คีย์ · 5 เครื่อง/คีย์

PRO

5 ผลิตภัณฑ์ · 1,000 คีย์ · 25 เครื่อง/คีย์

BUSINESS

ผลิตภัณฑ์และคีย์ไม่จำกัด · 100 เครื่อง/คีย์

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