SDK downloads

Java #

Apply for a payout

ApplyRequest request = ApplyRequest.builder()
        .mchOrderNo("ORDER-20260917-0001")
        .amountCents(Amounts.yuanToCents("19.99"))
        .accountName("张三")
        .accountNo("6222021234567890123")
        .bankName("中国工商银行")
        .notifyUrl("https://your-callback-host/std1/notify")
        .extra("productId", "2")   // optional payout product code, sent as an extra field; omit it to use your default payout product
        .build();
Std1Result result = client.applyPayout(request);
// SUCCESS = accepted and funds frozen, NOT paid yet; see section 8 for the rest.

Receive callbacks

protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    byte[] body = readAll(req.getInputStream());          // 只读正文字节，别碰 getParameter*
    try {
        PayoutNotification n = client.parseNotification(body);
        saveIfNewer(n.getPayoutNo(), n.getStatus(), n);    // 你的落库逻辑（按 payoutNo+status 去重）
        resp.setStatus(200);
        resp.getWriter().write(Std1Client.SUCCESS_REPLY);
    } catch (InvalidNotificationException e) {
        resp.setStatus(400);                               // e.getReason(): malformed / signature / merchant / fields
        resp.getWriter().write("fail");
    }
}

PHP #

Apply for a payout

$request = new \Std1\Payout\ApplyRequest([
    'mchOrderNo'  => 'A20260917000001',                               // unique per merchant: the idempotency key
    'amount'      => \Std1\Payout\Amounts::yuanToCents('100.00'),     // '10000' minor units; never 100.00 * 100
    'accountName' => 'Nguyen Van A',
    'accountNo'   => '6222021234567890123',
    'bankName'    => '中国工商银行',
    'notifyUrl'   => 'https://<your-callback-host>/std1/notify',     // optional
    'remark'      => 'salary',                                        // optional, echoed back
], ['myBatch' => '0917',                                              // optional merchant-defined fields
    'productId' => '2']);                                             // optional payout product code; omit it to use your default payout product

// Store these parameters with the order BEFORE sending: an UNKNOWN result must be retried with exactly the same parameters.
$result = $client->applyPayout($request);
// SUCCESS = accepted and funds frozen, NOT paid; REJECTED = rejected (final), this merchant order number is used up, use a NEW one to pay out;
// NOT_PROCESSED = fix and resend with the SAME order number; UNKNOWN = retry the same order number with identical parameters, or query.

Receive callbacks

$raw = file_get_contents('php://input');          // never $_POST or $_REQUEST
try {
    $notification = $client->parseNotification($raw);   // or Notification::parse($raw, $mchId, $key) without a client
} catch (\Std1\Payout\InvalidNotificationException $e) {
    http_response_code(400);
    echo 'fail';
    exit;
}
// Persist first (de-duplicate by payoutNo + status; accept only forward moves via Statuses::isNewer), then:
echo \Std1\Payout\Client::SUCCESS_REPLY;

Python #

Apply for a payout

request = std1.ApplyRequest(mch_order_no="ORDER-20260917-0001", amount=std1.yuan_to_cents("19.99"), account_name="张三",
                            account_no="6222021234567890123", bank_name="中国工商银行", notify_url="https://your-host/std1/notify",
                            extra={"productId": "2"})  # optional payout product code; omit it to use your default payout product
result = client.apply_payout(request)
# SUCCESS: accepted and funds frozen (NOT paid yet) · REJECTED: the order is rejected (final) and this merchant order number is used up; use a NEW merchant order number to pay out
# NOT_PROCESSED: nothing happened; fix it and resend with the SAME number · UNKNOWN: retry with the same number and identical parameters, or query

Receive callbacks

@app.post("/std1/notify")
def std1_notify():
    try:
        notification = client.parse_notification(request.get_data())   # raw body bytes
    except std1.InvalidNotification:
        return "fail", 400                                            # never reply success to an invalid callback
    save_once(notification.payout_no, notification.status, notification)   # persist first (dedupe on payoutNo + status)
    return std1.SUCCESS_REPLY, 200

Go #

Apply for a payout

cents, _ := std1payout.YuanToCents("19.99")
result, err := client.ApplyPayout(ctx, std1payout.ApplyRequest{
    MchOrderNo: "ORDER-20260917-0001", Amount: cents,
    AccountName: "张三", AccountNo: "6222021234567890123", BankName: "中国工商银行",
    NotifyURL: "https://your-callback/std1/notify",
    Extra: []std1payout.Param{{Name: "productId", Value: "2"}}, // optional payout product code; omit it to use your default payout product
})
// err != nil only for invalid input (nothing was sent).
// result.Outcome: SUCCESS (accepted, funds frozen, NOT paid yet), REJECTED (use a NEW order number to pay),
// NOT_PROCESSED (fix and resend with the SAME order number), UNKNOWN (retry with the same order number and
// identical parameters, or query; never switch order numbers).

Receive callbacks

http.Handle("/std1/notify", client.NotificationHandler(func(n *std1payout.Notification) error {
    // de-duplicate by n.PayoutNo + n.Status, accept only forward moves (IsNewerStatus), store first
    return saveResult(n) // nil → HTTP 200 "success"; error → 500 and the gateway retries later
}))

Node.js（TypeScript） #

Apply for a payout

const result = await client.applyPayout({
  mchOrderNo: 'ORDER-20260917-0001',  // retries MUST reuse the same order number and identical parameters
  amount: yuanToCents('100.00'),       // integer minor units only: '10000', 10000 or 10000n
  accountName: 'Nguyen Van A',
  accountNo: '6222021234567890123',
  bankName: 'BANK NAME',
  notifyUrl: 'https://YOUR_CALLBACK_HOST/std1/notify',
  remark: 'salary',
  extra: [
    ['myTraceId', 'T-1'],              // optional merchant-defined fields (signed, ignored by the gateway)
    ['productId', '2'],                // optional payout product code; omit it to use your default payout product
  ],
});

if (result.outcome === Outcome.SUCCESS) {
  // accepted and funds frozen, NOT paid yet — wait for the callback or query
} else if (result.outcome === Outcome.REJECTED) {
  // the order is rejected (final) and this merchant order number is used up; use a NEW merchant order number to pay out
} else if (result.outcome === Outcome.NOT_PROCESSED) {
  // nothing was done; fix the cause and resend with the SAME order number
} else {
  // UNKNOWN: retry with the same order number and identical parameters, or query; never switch order numbers
}

Receive callbacks

app.post('/std1/notify', express.raw({ type: '*/*', limit: '64kb' }), async (req, res) => {
  let notification;
  try {
    notification = client.parseNotification(req.body); // Buffer — never the parsed object, never merged with req.query
  } catch (error) {
    return res.status(400).type('text/plain').send('fail'); // do not reply success; the gateway will retry
  }
  await saveOnce(notification.payoutNo, notification.status, notification); // store first, then reply
  res.status(200).type('text/plain').send(SUCCESS_REPLY);
});

.NET #

Apply for a payout

var request = new ApplyRequest
{
    MchOrderNo = "ORDER-20260917-0001",      // your order number: unique per merchant, the idempotency key
    Amount = Amounts.YuanToCents("100.00"),  // "10000" — always minor units; or request.SetAmountCents(10000)
    AccountName = "Nguyen Van A",
    AccountNo = "6222021234567890123",
    BankName = "中国工商银行",
    NotifyUrl = "https://回调地址/std1/notify",  // optional; without it there is no callback, only queries
    Remark = "salary",                         // optional; echoed by queries and callbacks
};
request.AddExtra("myTag", "vip");             // optional merchant fields: signed, ignored by the gateway
request.AddExtra("productId", "2");           // optional payout product code; omit it to use your default payout product

// Store the order number and these exact parameters first: an UNKNOWN result must be resent unchanged
Std1Result result = await client.ApplyPayoutAsync(request);
switch (result.Outcome)
{
    case Outcome.Success:       // accepted and frozen, NOT paid yet: wait for the callback or query
        SavePayoutNo(request.MchOrderNo, result.PayoutNo);
        break;
    case Outcome.Rejected:      // rejected: the order is rejected (final) and this merchant order number is used up; use a NEW merchant order number to pay out
        MarkRejected(request.MchOrderNo, result.Code, result.Message);
        break;
    case Outcome.NotProcessed:  // not processed: fix the cause and resend with the SAME order number
        Alert(result.HintEn);
        break;
    default:                    // Unknown: resend with the same number and identical parameters, or query
        ScheduleRetryOrQuery(request.MchOrderNo);
        break;
}

Receive callbacks

app.MapPost("/std1/notify", async (HttpRequest http) =>
{
    byte[] body;
    using (var buffer = new MemoryStream())
    {
        await http.Body.CopyToAsync(buffer);
        body = buffer.ToArray();
    }
    PayoutNotification n;
    try
    {
        n = client.ParseNotification(body);
    }
    catch (InvalidNotificationException e)       // e.Reason: malformed / signature / merchant / fields
    {
        Console.Error.WriteLine("invalid std1 callback: " + e.Reason);
        return Results.Text("fail", statusCode: 400);
    }
    await SaveIfNewerAsync(n);                   // dedupe by PayoutNo + Status; accept forward moves only
    return Results.Text(Std1Client.SuccessReply);
});