Запрос баланса счета

URL

POSThttps://api-merchant.alikassa.com/v1/account/balance📋

Заголовки

Заголовок	Значение
Content-Type	application/json
Account	Ваш uuid счета (вы можете найти в разделе Счета)
Sign	Подпись запроса

Ответ

Название	Описание
currency	Валюта счёта
balance	Актуальный баланс
hold	Холд
rolling_reserve	Роллинг
pending_payouts	Сумма нефинализированных выплат

Примеры ответов

Успешный ответ (HTTP CODE 200)

{
  "currency": "RUB",
  "balance": "93.84000000",
  "hold": "0.00000000",
  "rolling_reserve": "0.00000000",
  "pending_payouts": "1234.00000000"
}

Ошибка ответа (HTTP CODE 400)

{
  "message": "The given data was invalid.",
  "errors": {
    // ...
  }
}

Важные замечания

предупреждение

При запросе баланса, используйте сертификат на выплату

Пример реализации

function requestBalance(string $method, string $account, array $data)
{
    $data = json_encode($data);

    $privateKey = openssl_pkey_get_private(
        file_get_contents(__DIR__ . '/cert/payout/private.pem'),
        file_get_contents(__DIR__ . '/cert/payout/password.txt')
    );

    if ($privateKey === false) {
        throw new \Exception('Ошибка сертификата.');
    }

    openssl_sign($data, $sign, $privateKey);
    $sign = base64_encode($sign);

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, 'https://api-merchant.alikassa.com/' . $method);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'Account: ' . $account,
        'Sign: ' . $sign,
    ]);
    curl_setopt($ch, CURLOPT_HEADER, 0);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
    curl_setopt($ch, CURLOPT_USERAGENT, 'AliKassa2.0 API');
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);

    $response = curl_exec($ch);

    return json_decode($response, true);
}

$payment = requestBalance(
    'v1/account/balance',
    '93d5df06-996c-48c3-9847-348d6b580b80',
    []
);

var_dump($payment);

import { readFileSync } from 'fs';
import { createSign } from 'crypto';
import https from 'https';

async function requestBalance(method, account, data) {
  const body = JSON.stringify(data);
  const keyPem = readFileSync('cert/payout/private.pem', 'utf8');
  const pass = readFileSync('cert/payout/password.txt', 'utf8').trim();
  const signer = createSign('SHA256');
  signer.update(body);
  signer.end();
  const sign = signer.sign({ key: keyPem, passphrase: pass }, 'base64');
  const options = {
    hostname: 'api-merchant.alikassa.com',
    path: `/${method}`,
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Account: account,
      Sign: sign,
      'User-Agent': 'AliKassa2.0 API',
    },
    timeout: 30000,
  };
  return new Promise((res, rej) => {
    const req = https.request(options, (r) => {
      let data = '';
      r.on('data', (c) => (data += c));
      r.on('end', () => res(JSON.parse(data)));
    });
    req.on('error', rej);
    req.write(body);
    req.end();
  });
}

(async () => {
  const payment = await requestBalance(
    'v1/account/balance',
    '93d5df06-996c-48c3-9847-348d6b580b80',
    {}
  );
  console.log(payment);
})();

import json
import base64
import requests
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding

def request_balance(method: str, account: str, data: dict):
    payload = json.dumps(data).encode()
    password = open('cert/payout/password.txt','rb').read().strip()
    private_key = serialization.load_pem_private_key(
        open('cert/payout/private.pem','rb').read(),
        password=password
    )
    signature = private_key.sign(payload, padding.PKCS1v15(), hashes.SHA256())
    sign = base64.b64encode(signature).decode()
    headers = {
        'Content-Type': 'application/json',
        'Account': account,
        'Sign': sign,
        'User-Agent': 'AliKassa2.0 API'
    }
    resp = requests.post(f'https://api-merchant.alikassa.com/{method}', data=payload, headers=headers, timeout=30)
    return resp.json()

payment = request_balance('v1/account/balance', '93d5df06-996c-48c3-9847-348d6b580b80', {})
print(payment)

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.Signature;
import java.util.Base64;
import java.util.Map;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.bouncycastle.openssl.PEMEncryptedKeyPair;
import org.bouncycastle.openssl.PEMParser;
import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder;
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;

public class Example {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        byte[] dataBytes = mapper.writeValueAsBytes(Map.of());
        char[] pass = Files.readString(Paths.get("cert/payout/password.txt")).toCharArray();
        PEMParser parser = new PEMParser(Files.newBufferedReader(Paths.get("cert/payout/private.pem")));
        PEMEncryptedKeyPair ckp = (PEMEncryptedKeyPair) parser.readObject();
        var privateKey = new JcaPEMKeyConverter()
            .getKeyPair(ckp.decryptKeyPair(new JcePEMDecryptorProviderBuilder().build(pass)))
            .getPrivate();
        Signature sig = Signature.getInstance("SHA256withRSA");
        sig.initSign(privateKey);
        sig.update(dataBytes);
        String sign = Base64.getEncoder().encodeToString(sig.sign());
        HttpRequest req = HttpRequest.newBuilder()
            .uri(java.net.URI.create("https://api-merchant.alikassa.com/v1/account/balance"))
            .header("Content-Type", "application/json")
            .header("Account", "93d5df06-996c-48c3-9847-348d6b580b80")
            .header("Sign", sign)
            .header("User-Agent", "AliKassa2.0 API")
            .POST(HttpRequest.BodyPublishers.ofString(new String(dataBytes, StandardCharsets.UTF_8)))
            .build();
        var client = HttpClient.newHttpClient();
        var response = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(mapper.readValue(response.body(), Object.class));
    }
}

package main

import (
    "bytes"
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "crypto/x509"
    "encoding/base64"
    "encoding/json"
    "encoding/pem"
    "io/ioutil"
    "net/http"
    "time"
    "fmt"
)

func signData(data []byte) string {
    pemBytes, _ := ioutil.ReadFile("cert/payout/private.pem")
    passBytes, _ := ioutil.ReadFile("cert/payout/password.txt")
    block, _ := pem.Decode(pemBytes)
    der, _ := x509.DecryptPEMBlock(block, passBytes)
    priv, _ := x509.ParsePKCS1PrivateKey(der)
    hash := sha256.Sum256(data)
    sig, _ := rsa.SignPKCS1v15(rand.Reader, priv, crypto.SHA256, hash[:])
    return base64.StdEncoding.EncodeToString(sig)
}

func requestBalance(method, account string, data interface{}) (map[string]interface{}, error) {
    body, _ := json.Marshal(data)
    sign := signData(body)
    req, _ := http.NewRequest("POST", "https://api-merchant.alikassa.com/"+method, bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Account", account)
    req.Header.Set("Sign", sign)
    req.Header.Set("User-Agent", "AliKassa2.0 API")
    client := &http.Client{Timeout: 30 * time.Second}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

func main() {
    payment, _ := requestBalance("v1/account/balance", "93d5df06-996c-48c3-9847-348d6b580b80", nil)
    fmt.Println(payment)
}