首页 / API 调用文档

API 调用文档

请使用 HTTPS，请求方式为 POST，正文为 JSON（UTF-8）。是否成功以返回里的 success 为准。

概述与约定

基础地址：https://你的域名

请求

POST

请求头

Content-Type: application/json

响应

JSON · utf-8

返回结构（data 可有可无）：

{
  "success": true | false,
  "message": "说明文字",
  "data": { }
}

卡密验证 POST /api/verify.php

首次验证成功会记为已使用；已使用或过期时返回不同，部分情况带 data。

POST https://你的域名/api/verify.php

请求参数（Body JSON）

「JSON 类型」列表示该字段在 JSON 里是文本（string），不是固定词「字符串」；实际要传的内容见「说明」列（你的 api_key、card_key 等）。

参数	JSON 类型	必填	说明
`api_key`	string	是	你的 API 密钥
`card_key`	string	是	待验证的卡密
`user_info`	string	否	可选备注，如设备号

注意频率：请勿短时间高频调用；触发限流时将暂时拒绝请求，稍后再试。

data 常见字段

字段	说明
`card_type`、`duration`	随业务返回，取值以实际为准
`used_at`、`expire_at`	时间相关字段（若有）
`is_used`	是否曾核销；与 success 组合判断，须核对本字段

说明

success 为 true：新验证与重复验证的语义不同，须结合 data.is_used 与返回说明区分。
success 为 false：参数、限流、密钥、卡状态错误等，务必查看 message。

示例

{
  "success": true,
  "message": "…",
  "data": { "card_type": "…", "duration": 0, "is_used": false }
}

{ "success": false, "message": "…" }

卡密查询 POST /api/query.php

仅查询、不核销。只需 card_key，不需要 api_key。类型与状态为中文文案。

POST https://你的域名/api/query.php

参数	必填
`card_key`	是

示例代码（验证接口）

替换为你的域名与密钥；查询接口则换 URL，请求体只需 card_key。

 "your_api_key", "card_key" => "your_card_key"];
$ch = curl_init($url);
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => json_encode($data, JSON_UNESCAPED_UNICODE),
    CURLOPT_HTTPHEADER => ["Content-Type: application/json"],
    CURLOPT_RETURNTRANSFER => true,
]);
echo curl_exec($ch);
curl_close($ch);

const url = "https://你的域名/api/verify.php";
const res = await fetch(url, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    api_key: "your_api_key",
    card_key: "your_card_key",
  }),
});
console.log(await res.json());

const url = "https://你的域名/api/verify.php";
const res = await fetch(url, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    api_key: "your_api_key",
    card_key: "your_card_key",
  }),
});
console.log(await res.json());

const https = require("https");
const url = new URL("https://你的域名/api/verify.php");
const body = JSON.stringify({
  api_key: "your_api_key",
  card_key: "your_card_key",
});
const opts = {
  hostname: url.hostname,
  port: 443,
  path: url.pathname + (url.search || ""),
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Content-Length": Buffer.byteLength(body),
  },
};
const req = https.request(opts, (res) => {
  let d = "";
  res.on("data", (c) => { d += c; });
  res.on("end", () => console.log(d));
});
req.on("error", console.error);
req.write(body);
req.end();

import json
import urllib.request

url = "https://你的域名/api/verify.php"
payload = {"api_key": "your_api_key", "card_key": "your_card_key"}
data = json.dumps(payload).encode("utf-8")
req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
with urllib.request.urlopen(req) as resp:
    print(resp.read().decode("utf-8"))

package main

import (
    "bytes"
    "encoding/json"
    "io"
    "net/http"
    "os"
)

func main() {
    url := "https://你的域名/api/verify.php"
    body, _ := json.Marshal(map[string]string{
        "api_key": "your_api_key",
        "card_key": "your_card_key",
    })
    resp, err := http.Post(url, "application/json", bytes.NewReader(body))
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    io.Copy(os.Stdout, resp.Body)
}

import java.net.URI;
import java.net.http.*;
import java.time.Duration;

var client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(15)).build();
var url = "https://你的域名/api/verify.php";
var body = "{\"api_key\":\"your_api_key\",\"card_key\":\"your_card_key\"}";
var req = HttpRequest.newBuilder(URI.create(url))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body))
    .build();
var res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

import java.net.HttpURLConnection
import java.net.URL

fun main() {
    val url = URL("https://你的域名/api/verify.php")
    val conn = url.openConnection() as HttpURLConnection
    conn.requestMethod = "POST"
    conn.setRequestProperty("Content-Type", "application/json")
    conn.doOutput = true
    val body = """{"api_key":"your_api_key","card_key":"your_card_key"}"""
    conn.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
    println(conn.inputStream.bufferedReader().readText())
}

import Foundation

let url = URL(string: "https://你的域名/api/verify.php")!
var req = URLRequest(url: url)
req.httpMethod = "POST"
req.setValue("application/json", forHTTPHeaderField: "Content-Type")
req.httpBody = #"{"api_key":"your_api_key","card_key":"your_card_key"}"#.data(using: .utf8)
let sem = DispatchSemaphore(value: 0)
URLSession.shared.dataTask(with: req) { data, _, _ in
    print(String(data: data ?? Data(), encoding: .utf8) ?? "")
    sem.signal()
}.resume()
sem.wait()

// pubspec.yaml: dependencies: http: ^1.0
import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final r = await http.post(
    Uri.parse('https://你的域名/api/verify.php'),
    headers: {'Content-Type': 'application/json'},
    body: jsonEncode({
      'api_key': 'your_api_key',
      'card_key': 'your_card_key',
    }),
  );
  print(r.body);
}

require "net/http"
require "json"

uri = URI("https://你的域名/api/verify.php")
req = Net::HTTP::Post.new(uri)
req["Content-Type"] = "application/json"
req.body = { api_key: "your_api_key", card_key: "your_card_key" }.to_json
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

// Cargo.toml: reqwest = { version = "0.11", features = ["blocking", "json"] }
// serde_json = "1"
use reqwest::blocking::Client;
use serde_json::json;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let res = Client::new()
        .post("https://你的域名/api/verify.php")
        .json(&json!({
            "api_key": "your_api_key",
            "card_key": "your_card_key",
        }))
        .send()?;
    println!("{}", res.text()?);
    Ok(())
}

using System.Net.Http;
using System.Text;

using var client = new HttpClient();
var json = "{\"api_key\":\"your_api_key\",\"card_key\":\"your_card_key\"}";
var content = new StringContent(json, Encoding.UTF8, "application/json");
var res = await client.PostAsync("https://你的域名/api/verify.php", content);
Console.WriteLine(await res.Content.ReadAsStringAsync());

$uri = "https://你的域名/api/verify.php"
$body = @{ api_key = "your_api_key"; card_key = "your_card_key" } | ConvertTo-Json
Invoke-RestMethod -Uri $uri -Method Post -Body $body -ContentType "application/json"

wget -qO- --post-data='{"api_key":"your_api_key","card_key":"your_card_key"}' \
  --header='Content-Type: application/json' \
  "https://你的域名/api/verify.php"

-- 依赖系统已安装 curl
local cmd = [[curl -s -X POST "https://你的域名/api/verify.php" -H "Content-Type: application/json" -d "{\"api_key\":\"your_api_key\",\"card_key\":\"your_card_key\"}"]]
local h = assert(io.popen(cmd))
print(h:read("*a"))
h:close()

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $res = $ua->post(
    'https://你的域名/api/verify.php',
    Content_Type => 'application/json',
    Content => '{"api_key":"your_api_key","card_key":"your_card_key"}',
);
print $res->decoded_content;

library(httr)

r <- POST(
  "https://你的域名/api/verify.php",
  body = list(api_key = "your_api_key", card_key = "your_card_key"),
  encode = "json"
)
content(r, "text")

import java.net.{HttpURLConnection, URL}
import scala.io.Source

val url = new URL("https://你的域名/api/verify.php")
val conn = url.openConnection().asInstanceOf[HttpURLConnection]
conn.setRequestMethod("POST")
conn.setRequestProperty("Content-Type", "application/json")
conn.setDoOutput(true)
conn.getOutputStream.write("""{"api_key":"your_api_key","card_key":"your_card_key"}""".getBytes("UTF-8"))
println(Source.fromInputStream(conn.getInputStream).mkString)

# mix.exs: {:req, "~> 0.4"}
Req.post!("https://你的域名/api/verify.php",
  json: %{api_key: "your_api_key", card_key: "your_card_key"}
).body

import std/httpclient

let c = newHttpClient()
c.headers = newHttpHeaders({"Content-Type": "application/json"})
echo c.postContent("https://你的域名/api/verify.php",
  """{"api_key":"your_api_key","card_key":"your_card_key"}""")

require "http/client"

resp = HTTP::Client.post(
  "https://你的域名/api/verify.php",
  headers: HTTP::Headers{"Content-Type" => "application/json"},
  body: %({"api_key":"your_api_key","card_key":"your_card_key"})
)
puts resp.body

using HTTP
using JSON

url = "https://你的域名/api/verify.php"
body = JSON.json(Dict("api_key" => "your_api_key", "card_key" => "your_card_key"))
resp = HTTP.post(url, ["Content-Type" => "application/json"], body)
println(String(resp.body))

url = 'https://你的域名/api/verify.php';
body = struct('api_key','your_api_key','card_key','your_card_key');
opts = weboptions('MediaType','application/json','RequestMethod','post');
txt = webwrite(url, body, opts);
disp(txt);

(require '[clj-http.client :as client])

(println (:body
  (client/post "https://你的域名/api/verify.php"
    {:headers {"Content-Type" "application/json"}
     :body "{\"api_key\":\"your_api_key\",\"card_key\":\"your_card_key\"}"})))

curl -X POST "https://你的域名/api/verify.php" \
  -H "Content-Type: application/json" \
  -d "{\"api_key\":\"your_api_key\",\"card_key\":\"your_card_key\"}"