# 需要 jq 和 openssl
API_HOST="https://<api-host>"        # 接入地址，见商户后台“API 配置”
API_SECRET="<your API secret>"       # API 密钥，只保存在服务端
API_PATH="/api/v1/payins/query"
BODY='{"merchant_id":"10001","merchant_order_id":"ORDER-10001"}'

# 去掉 sign，按键名排序，生成紧凑 JSON
CANONICAL=$(printf '%s' "$BODY" | jq -cS 'del(.sign)')
SIGN=$(printf 'POST\n%s\n%s' "$API_PATH" "$CANONICAL" \
  | openssl dgst -sha256 -hmac "$API_SECRET" | awk '{print $NF}')

curl -X POST "$API_HOST$API_PATH" \
  -H "Content-Type: application/json" \
  -d "$(printf '%s' "$CANONICAL" | jq -c --arg sign "$SIGN" '. + {sign: $sign}')"

import hashlib, hmac, json
from urllib.request import Request, urlopen

API_HOST = "https://<api-host>"      # 接入地址，见商户后台“API 配置”
MERCHANT_ID = "10001"                # 商户编号
API_SECRET = "<your API secret>"     # API 密钥，只保存在服务端


def canonical(payload):
    # 去掉 sign，按键名排序，生成紧凑 JSON
    unsigned = {k: v for k, v in payload.items() if k != "sign"}
    return json.dumps(unsigned, sort_keys=True, ensure_ascii=False,
                      separators=(",", ":"), allow_nan=False)


def call(path, fields):
    payload = {"merchant_id": MERCHANT_ID, **fields}
    message = "POST\n" + path + "\n" + canonical(payload)
    payload["sign"] = hmac.new(API_SECRET.encode(), message.encode("utf-8"),
                               hashlib.sha256).hexdigest()
    request = Request(API_HOST + path, method="POST",
                      data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
                      headers={"Content-Type": "application/json"})
    with urlopen(request, timeout=15) as response:
        return json.load(response)


print(call("/api/v1/payins/query", {"merchant_order_id": "ORDER-10001"}))

<?php
const API_HOST = 'https://<api-host>';     // 接入地址，见商户后台“API 配置”
const MERCHANT_ID = '10001';               // 商户编号
const API_SECRET = '<your API secret>';    // API 密钥，只保存在服务端
const JSON_FLAGS = JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES;

// 去掉 sign，按键名排序，生成紧凑 JSON
// 空对象请用 new stdClass()，不要用 []
function canonical($value): string {
    if (is_array($value) && array_is_list($value)) {
        return '[' . implode(',', array_map('canonical', $value)) . ']';
    }
    if (is_array($value) || is_object($value)) {
        $fields = (array) $value;
        ksort($fields, SORT_STRING);
        $parts = [];
        foreach ($fields as $key => $item) {
            $parts[] = json_encode((string) $key, JSON_FLAGS) . ':' . canonical($item);
        }
        return '{' . implode(',', $parts) . '}';
    }
    return json_encode($value, JSON_FLAGS);
}

function call(string $path, array $fields): array {
    $payload = ['merchant_id' => MERCHANT_ID] + $fields;
    unset($payload['sign']);
    $message = "POST\n" . $path . "\n" . canonical($payload);
    $payload['sign'] = hash_hmac('sha256', $message, API_SECRET);
    $ch = curl_init(API_HOST . $path);
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
        CURLOPT_POSTFIELDS => json_encode($payload, JSON_FLAGS),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 15,
    ]);
    $response = curl_exec($ch);
    curl_close($ch);
    return json_decode($response, true);
}

print_r(call('/api/v1/payins/query', ['merchant_order_id' => 'ORDER-10001']));

// Java 17+，无第三方依赖
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.*;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class WinniePay {
    static final String API_HOST = "https://<api-host>";    // 接入地址，见商户后台“API 配置”
    static final String MERCHANT_ID = "10001";              // 商户编号
    static final String API_SECRET = "<your API secret>";   // API 密钥，只保存在服务端

    // 去掉 sign，按键名排序，生成紧凑 JSON
    static String canonical(Object value) {
        if (value instanceof Map<?, ?> map) {
            StringJoiner out = new StringJoiner(",", "{", "}");
            new TreeMap<>(map).forEach((k, v) -> out.add(quote((String) k) + ":" + canonical(v)));
            return out.toString();
        }
        if (value instanceof List<?> list) {
            StringJoiner out = new StringJoiner(",", "[", "]");
            list.forEach(v -> out.add(canonical(v)));
            return out.toString();
        }
        if (value instanceof String s) return quote(s);
        return String.valueOf(value);  // null, true/false, whole numbers
    }

    static String quote(String s) {
        StringBuilder b = new StringBuilder("\"");
        for (char c : s.toCharArray()) {
            switch (c) {
                case '"' -> b.append("\\\"");
                case '\\' -> b.append("\\\\");
                case '\n' -> b.append("\\n");
                case '\r' -> b.append("\\r");
                case '\t' -> b.append("\\t");
                case '\b' -> b.append("\\b");
                case '\f' -> b.append("\\f");
                default -> b.append(c < 0x20 ? String.format("\\u%04x", (int) c) : String.valueOf(c));
            }
        }
        return b.append('"').toString();
    }

    static String hmac(String secret, String message) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        return HexFormat.of().formatHex(mac.doFinal(message.getBytes(StandardCharsets.UTF_8)));
    }

    static String call(String path, Map<String, Object> fields) throws Exception {
        Map<String, Object> payload = new TreeMap<>(fields);
        payload.put("merchant_id", MERCHANT_ID);
        payload.remove("sign");
        String body = canonical(payload);
        String sign = hmac(API_SECRET, "POST\n" + path + "\n" + body);
        String signed = body.substring(0, body.length() - 1) + ",\"sign\":" + quote(sign) + "}";
        HttpRequest request = HttpRequest.newBuilder(URI.create(API_HOST + path))
                .header("Content-Type", "application/json")
                .timeout(Duration.ofSeconds(15))
                .POST(HttpRequest.BodyPublishers.ofString(signed, StandardCharsets.UTF_8))
                .build();
        return HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString()).body();
    }

    public static void main(String[] args) throws Exception {
        System.out.println(call("/api/v1/payins/query", Map.of("merchant_order_id", "ORDER-10001")));
    }
}

// Node.js 18+
const crypto = require("crypto");

const API_HOST = "https://<api-host>";    // 接入地址，见商户后台“API 配置”
const MERCHANT_ID = "10001";              // 商户编号
const API_SECRET = "<your API secret>";   // API 密钥，只保存在服务端

// 去掉 sign，按键名排序，生成紧凑 JSON
function canonicalJson(value) {
  if (Array.isArray(value)) return "[" + value.map(canonicalJson).join(",") + "]";
  if (value !== null && typeof value === "object") {
    return "{" + Object.keys(value).sort()
      .map((k) => JSON.stringify(k) + ":" + canonicalJson(value[k])).join(",") + "}";
  }
  return JSON.stringify(value);
}

async function call(path, fields) {
  const payload = { merchant_id: MERCHANT_ID, ...fields };
  delete payload.sign;
  const message = `POST\n${path}\n${canonicalJson(payload)}`;
  payload.sign = crypto.createHmac("sha256", API_SECRET).update(message, "utf8").digest("hex");
  const response = await fetch(API_HOST + path, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });
  return response.json();
}

call("/api/v1/payins/query", { merchant_order_id: "ORDER-10001" }).then(console.log);

POST
/api/v1/payins/query
{"merchant_id":"10001","merchant_order_id":"ORDER-10001"}

5ab9bc491be52b3427b0ccaf9239448874b8212416738493509ffea4bc35d298

{
  "code": 200,
  "message": "success",
  "data": {
    "merchant_order_id": "ORDER-10001",
    "platform_order_id": "PI2026110312000000012345678",
    "amount": "1000.00",
    "paid_amount": "1000.00",
    "status": "SUCCESS",
    "merchant_fee": "40.00",
    "utr": "123456789012",
    "created_at": "2026-11-03T12:00:00+05:30",
    "paid_at": "2026-11-03T12:03:10+05:30",
    "callback_at": "2026-11-03T12:03:12+05:30",
    "test": false
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "platform_order_id": "PI2026110312000000012345678",
  "status": "SUCCESS",
  "amount": "1000.00",
  "paid_amount": "1000.00",
  "merchant_fee": "40.00",
  "message": "success",
  "completed_at": "2026-11-03T12:05:00+05:30",
  "sign": "<64 hex>"
}

# 需要 jq 和 openssl
# callback.json 为收到的回调正文
CALLBACK_SECRET="<your callback secret>"   # 回调密钥（不是 API 密钥）

SIGN=$(jq -r '.sign' callback.json)
EXPECTED=$(jq -cjS 'del(.sign)' callback.json \
  | openssl dgst -sha256 -hmac "$CALLBACK_SECRET" | awk '{print $NF}')

[ "$SIGN" = "$EXPECTED" ] && echo valid || echo invalid

import hashlib, hmac, json

CALLBACK_SECRET = "<your callback secret>"   # 回调密钥（不是 API 密钥）


def verify(payload):
    unsigned = {k: v for k, v in payload.items() if k != "sign"}
    message = json.dumps(unsigned, sort_keys=True, ensure_ascii=False,
                         separators=(",", ":"), allow_nan=False)
    expected = hmac.new(CALLBACK_SECRET.encode(), message.encode("utf-8"),
                        hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, payload.get("sign", ""))

# 验证通过并记录结果后，返回 HTTP 200、text/plain、正文 success

<?php
const CALLBACK_SECRET = '<your callback secret>';   // 回调密钥（不是 API 密钥）
// canonical() 与签名示例相同

function verify(string $rawBody): bool {
    $payload = json_decode($rawBody);   // 解析为对象，保留空对象 {}
    $sign = $payload->sign ?? '';
    unset($payload->sign);
    $expected = hash_hmac('sha256', canonical($payload), CALLBACK_SECRET);
    return hash_equals($expected, $sign);
}

// 验证通过并记录结果后，返回 HTTP 200、text/plain、正文 success

// 解析回调正文需要 Jackson（com.fasterxml.jackson.databind）
// canonical()、quote()、hmac() 与签名示例相同
static final String CALLBACK_SECRET = "<your callback secret>";   // 回调密钥（不是 API 密钥）

static boolean verify(String rawBody) throws Exception {
    Map<String, Object> payload = new com.fasterxml.jackson.databind.ObjectMapper()
            .readValue(rawBody, new com.fasterxml.jackson.core.type.TypeReference<Map<String, Object>>() {});
    Object sign = payload.remove("sign");
    String expected = hmac(CALLBACK_SECRET, canonical(payload));
    return sign instanceof String s && java.security.MessageDigest.isEqual(
            expected.getBytes(StandardCharsets.UTF_8), s.getBytes(StandardCharsets.UTF_8));
}

// 验证通过并记录结果后，返回 HTTP 200、text/plain、正文 success

const crypto = require("crypto");
// canonicalJson() 与签名示例相同
const CALLBACK_SECRET = "<your callback secret>";   // 回调密钥（不是 API 密钥）

// rawBody 为收到的回调正文（字符串）
function verify(rawBody) {
  const { sign = "", ...unsigned } = JSON.parse(rawBody);
  const expected = crypto.createHmac("sha256", CALLBACK_SECRET)
    .update(canonicalJson(unsigned), "utf8").digest("hex");
  return sign.length === expected.length
    && crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(sign));
}

// 验证通过并记录结果后，返回 HTTP 200、text/plain、正文 success

success

{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "amount": "1000.00",
  "notify_url": "https://merchant.example.com/payin/notify",
  "return_url": "https://merchant.example.com/payin/done",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payins' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "amount": "1000.00",
  "notify_url": "https://merchant.example.com/payin/notify",
  "return_url": "https://merchant.example.com/payin/done",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payins", {
    "merchant_order_id": "ORDER-10001",
    "amount": "1000.00",
    "notify_url": "https://merchant.example.com/payin/notify",
    "return_url": "https://merchant.example.com/payin/done",
})

// call() 见“请求签名”
$result = call('/api/v1/payins', [
    'merchant_order_id' => 'ORDER-10001',
    'amount' => '1000.00',
    'notify_url' => 'https://merchant.example.com/payin/notify',
    'return_url' => 'https://merchant.example.com/payin/done',
]);

// call() 见“请求签名”
String result = call("/api/v1/payins", Map.of(
    "merchant_order_id", "ORDER-10001",
    "amount", "1000.00",
    "notify_url", "https://merchant.example.com/payin/notify",
    "return_url", "https://merchant.example.com/payin/done"));

// call() 见“请求签名”
const result = await call("/api/v1/payins", {
    "merchant_order_id": "ORDER-10001",
    "amount": "1000.00",
    "notify_url": "https://merchant.example.com/payin/notify",
    "return_url": "https://merchant.example.com/payin/done",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "platform_order_id": "PI2026110312000000012345678",
    "merchant_order_id": "ORDER-10001",
    "amount": "1000.00",
    "payable_amount": "1000.00",
    "checkout_url": "https://pay.example.com/c/AbCdEf",
    "upi": "merchant@bank",
    "deeplink": "upi://pay?pa=merchant@bank&am=1000.00"
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payins/query' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payins/query", {
    "merchant_order_id": "ORDER-10001",
})

// call() 见“请求签名”
$result = call('/api/v1/payins/query', [
    'merchant_order_id' => 'ORDER-10001',
]);

// call() 见“请求签名”
String result = call("/api/v1/payins/query", Map.of(
    "merchant_order_id", "ORDER-10001"));

// call() 见“请求签名”
const result = await call("/api/v1/payins/query", {
    "merchant_order_id": "ORDER-10001",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "merchant_order_id": "ORDER-10001",
    "platform_order_id": "PI2026110312000000012345678",
    "amount": "1000.00",
    "paid_amount": "1000.00",
    "status": "SUCCESS",
    "merchant_fee": "40.00",
    "utr": "123456789012",
    "created_at": "2026-11-03T12:00:00+05:30",
    "paid_at": "2026-11-03T12:03:10+05:30",
    "callback_at": "2026-11-03T12:03:12+05:30",
    "test": false
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "utr": "123456789012",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payins/submit-utr' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "utr": "123456789012",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payins/submit-utr", {
    "merchant_order_id": "ORDER-10001",
    "utr": "123456789012",
})

// call() 见“请求签名”
$result = call('/api/v1/payins/submit-utr', [
    'merchant_order_id' => 'ORDER-10001',
    'utr' => '123456789012',
]);

// call() 见“请求签名”
String result = call("/api/v1/payins/submit-utr", Map.of(
    "merchant_order_id", "ORDER-10001",
    "utr", "123456789012"));

// call() 见“请求签名”
const result = await call("/api/v1/payins/submit-utr", {
    "merchant_order_id": "ORDER-10001",
    "utr": "123456789012",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "submitted": true
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "utr": "123456789012",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payins/utr-lookup' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "utr": "123456789012",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payins/utr-lookup", {
    "utr": "123456789012",
})

// call() 见“请求签名”
$result = call('/api/v1/payins/utr-lookup', [
    'utr' => '123456789012',
]);

// call() 见“请求签名”
String result = call("/api/v1/payins/utr-lookup", Map.of(
    "utr", "123456789012"));

// call() 见“请求签名”
const result = await call("/api/v1/payins/utr-lookup", {
    "utr": "123456789012",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "utr": "123456789012",
    "utr_status": "RECEIVED",
    "utr_amount": "1000.00",
    "received": 1,
    "supplemented": 0,
    "merchant_order_id": "ORDER-10001",
    "platform_order_id": "PI2026110312000000012345678",
    "status": "SUCCESS",
    "amount": "1000.00"
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "utr": "123456789012",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payins/supplements' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "utr": "123456789012",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payins/supplements", {
    "merchant_order_id": "ORDER-10001",
    "utr": "123456789012",
})

// call() 见“请求签名”
$result = call('/api/v1/payins/supplements', [
    'merchant_order_id' => 'ORDER-10001',
    'utr' => '123456789012',
]);

// call() 见“请求签名”
String result = call("/api/v1/payins/supplements", Map.of(
    "merchant_order_id", "ORDER-10001",
    "utr", "123456789012"));

// call() 见“请求签名”
const result = await call("/api/v1/payins/supplements", {
    "merchant_order_id": "ORDER-10001",
    "utr": "123456789012",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "merchant_order_id": "ORDER-10001",
    "platform_order_id": "PI2026110312000000012345678",
    "status": "PENDING",
    "utr": "123456789012",
    "actual_amount": null
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "utr": "123456789012",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payins/supplements/query' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "merchant_order_id": "ORDER-10001",
  "utr": "123456789012",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payins/supplements/query", {
    "merchant_order_id": "ORDER-10001",
    "utr": "123456789012",
})

// call() 见“请求签名”
$result = call('/api/v1/payins/supplements/query', [
    'merchant_order_id' => 'ORDER-10001',
    'utr' => '123456789012',
]);

// call() 见“请求签名”
String result = call("/api/v1/payins/supplements/query", Map.of(
    "merchant_order_id", "ORDER-10001",
    "utr", "123456789012"));

// call() 见“请求签名”
const result = await call("/api/v1/payins/supplements/query", {
    "merchant_order_id": "ORDER-10001",
    "utr": "123456789012",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "merchant_order_id": "ORDER-10001",
    "platform_order_id": "PI2026110312000000012345678",
    "status": "SUCCESS",
    "utr": "123456789012",
    "actual_amount": "1000.00"
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/upis' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/upis", {})

// call() 见“请求签名”
$result = call('/api/v1/upis', []);

// call() 见“请求签名”
String result = call("/api/v1/upis", Map.of());

// call() 见“请求签名”
const result = await call("/api/v1/upis", {});

{
  "code": 200,
  "message": "success",
  "data": {
    "upis": [
      "merchant@bank",
      "shop@upi"
    ]
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "upi": "merchant@bank",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/upis/lookup' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "upi": "merchant@bank",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/upis/lookup", {
    "upi": "merchant@bank",
})

// call() 见“请求签名”
$result = call('/api/v1/upis/lookup', [
    'upi' => 'merchant@bank',
]);

// call() 见“请求签名”
String result = call("/api/v1/upis/lookup", Map.of(
    "upi", "merchant@bank"));

// call() 见“请求签名”
const result = await call("/api/v1/upis/lookup", {
    "upi": "merchant@bank",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "upi": "merchant@bank",
    "status": "ACTIVE",
    "exists": 1
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "merchant_order_id": "PAYOUT-20001",
  "amount": "500.00",
  "bank_account": {
    "beneficiary_name": "Ravi Kumar",
    "account_number": "123456789012",
    "ifsc": "HDFC0001234",
    "bank_name": "HDFC Bank",
    "phone": "9876543210",
    "email": "ravi@example.com"
  },
  "notify_url": "https://merchant.example.com/payout/notify",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payouts' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "merchant_order_id": "PAYOUT-20001",
  "amount": "500.00",
  "bank_account": {
    "beneficiary_name": "Ravi Kumar",
    "account_number": "123456789012",
    "ifsc": "HDFC0001234",
    "bank_name": "HDFC Bank",
    "phone": "9876543210",
    "email": "ravi@example.com"
  },
  "notify_url": "https://merchant.example.com/payout/notify",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payouts", {
    "merchant_order_id": "PAYOUT-20001",
    "amount": "500.00",
    "bank_account": {
        "beneficiary_name": "Ravi Kumar",
        "account_number": "123456789012",
        "ifsc": "HDFC0001234",
        "bank_name": "HDFC Bank",
        "phone": "9876543210",
        "email": "ravi@example.com",
    },
    "notify_url": "https://merchant.example.com/payout/notify",
})

// call() 见“请求签名”
$result = call('/api/v1/payouts', [
    'merchant_order_id' => 'PAYOUT-20001',
    'amount' => '500.00',
    'bank_account' => [
        'beneficiary_name' => 'Ravi Kumar',
        'account_number' => '123456789012',
        'ifsc' => 'HDFC0001234',
        'bank_name' => 'HDFC Bank',
        'phone' => '9876543210',
        'email' => 'ravi@example.com',
    ],
    'notify_url' => 'https://merchant.example.com/payout/notify',
]);

// call() 见“请求签名”
String result = call("/api/v1/payouts", Map.of(
    "merchant_order_id", "PAYOUT-20001",
    "amount", "500.00",
    "bank_account", Map.of(
        "beneficiary_name", "Ravi Kumar",
        "account_number", "123456789012",
        "ifsc", "HDFC0001234",
        "bank_name", "HDFC Bank",
        "phone", "9876543210",
        "email", "ravi@example.com"),
    "notify_url", "https://merchant.example.com/payout/notify"));

// call() 见“请求签名”
const result = await call("/api/v1/payouts", {
    "merchant_order_id": "PAYOUT-20001",
    "amount": "500.00",
    "bank_account": {
        "beneficiary_name": "Ravi Kumar",
        "account_number": "123456789012",
        "ifsc": "HDFC0001234",
        "bank_name": "HDFC Bank",
        "phone": "9876543210",
        "email": "ravi@example.com",
    },
    "notify_url": "https://merchant.example.com/payout/notify",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "merchant_order_id": "PAYOUT-20001",
    "platform_order_id": "PO2026110312000000012345678",
    "amount": "500.00"
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "merchant_order_id": "PAYOUT-20001",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payouts/query' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "merchant_order_id": "PAYOUT-20001",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payouts/query", {
    "merchant_order_id": "PAYOUT-20001",
})

// call() 见“请求签名”
$result = call('/api/v1/payouts/query', [
    'merchant_order_id' => 'PAYOUT-20001',
]);

// call() 见“请求签名”
String result = call("/api/v1/payouts/query", Map.of(
    "merchant_order_id", "PAYOUT-20001"));

// call() 见“请求签名”
const result = await call("/api/v1/payouts/query", {
    "merchant_order_id": "PAYOUT-20001",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "merchant_order_id": "PAYOUT-20001",
    "platform_order_id": "PO2026110312000000012345678",
    "amount": "500.00",
    "status": "SUCCESS",
    "merchant_fee": "10.00",
    "utr": "123456789012",
    "test": false
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "status": "SUCCESS",
  "page": 1,
  "page_size": 50,
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payouts/list' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "status": "SUCCESS",
  "page": 1,
  "page_size": 50,
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payouts/list", {
    "status": "SUCCESS",
    "page": 1,
    "page_size": 50,
})

// call() 见“请求签名”
$result = call('/api/v1/payouts/list', [
    'status' => 'SUCCESS',
    'page' => 1,
    'page_size' => 50,
]);

// call() 见“请求签名”
String result = call("/api/v1/payouts/list", Map.of(
    "status", "SUCCESS",
    "page", 1,
    "page_size", 50));

// call() 见“请求签名”
const result = await call("/api/v1/payouts/list", {
    "status": "SUCCESS",
    "page": 1,
    "page_size": 50,
});

{
  "code": 200,
  "message": "success",
  "data": {
    "count": 1,
    "next": null,
    "previous": null,
    "results": [
      {
        "merchant_order_id": "PAYOUT-20001",
        "platform_order_id": "PO2026110312000000012345678",
        "amount": "500.00",
        "status": "SUCCESS",
        "merchant_fee": "10.00",
        "utr": "123456789012"
      }
    ]
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "merchant_order_id": "PAYOUT-20001",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/payouts/receipt' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "merchant_order_id": "PAYOUT-20001",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/payouts/receipt", {
    "merchant_order_id": "PAYOUT-20001",
})

// call() 见“请求签名”
$result = call('/api/v1/payouts/receipt', [
    'merchant_order_id' => 'PAYOUT-20001',
]);

// call() 见“请求签名”
String result = call("/api/v1/payouts/receipt", Map.of(
    "merchant_order_id", "PAYOUT-20001"));

// call() 见“请求签名”
const result = await call("/api/v1/payouts/receipt", {
    "merchant_order_id": "PAYOUT-20001",
});

{
  "code": 200,
  "message": "success",
  "data": {
    "merchant_order_id": "PAYOUT-20001",
    "platform_order_id": "PO2026110312000000012345678",
    "receipt_url": "https://receipt.example.com/r#Zk3VwQ8sT1nYb6Lx0PqRjH2mCeUa9GdXoIf7KtNyB4s"
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}

{
  "merchant_id": "10001",
  "sign": "<64 hex>"
}

# sign 的算法见“请求签名”
curl --request POST 'https://<api-host>/api/v1/balances' \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "merchant_id": "10001",
  "sign": "<64 hex>"
}'

# call() 见“请求签名”
result = call("/api/v1/balances", {})

// call() 见“请求签名”
$result = call('/api/v1/balances', []);

// call() 见“请求签名”
String result = call("/api/v1/balances", Map.of());

// call() 见“请求签名”
const result = await call("/api/v1/balances", {});

{
  "code": 200,
  "message": "success",
  "data": {
    "available_balance": "125000.00",
    "frozen_balance": "8000.00",
    "order_frozen_balance": "0.00"
  }
}

{
  "code": 500,
  "message": "该商户订单号已使用过，本次内容与原订单不一致",
  "data": null
}