Team Quickex

1. Dezember 2025

Pre-calculating rate

Algorithm

Quickex verwendet ein dynamisches Kurssystem, um Wechselkursprognosen zu erzeugen, wobei die Markttiefe der Liquiditätsanbieter analysiert wird. Während der Standard-Flow die Markttiefe analysiert und ein realistisch berechnetes Ergebnis zurückgibt, kann der Parameter markup den vom Kursprognose-Algorithmus zurückgegebenen Kurs beeinflussen.

Der Parameter markup beeinflusst die Vorab-Berechnung des Kurses, die von unserem System zurückgegeben wird, auf folgende Weise:

A_final = A_calculated × (1 − (K_markup / 100))

Parameter	Beschreibung
A_final	Endbetrag, der empfangen wird (prognostiziert)
A_calculated	Betrag vor Anwendung des Markups
K_markup	Markup-Prozentsatz

Auf Grundlage der angegebenen Formel führt ein markup-Wert von 0.3, der für einen Tausch von 1 BTC → USDT übergeben wird, zu den folgenden Ergebnissen; der endgültige prognostizierte Preis erhöht sich dabei um 0,3 %:

Beispiel: 49549.728053855135 * (1 – \dfrac{0.3}{100}) = 49401.07886969357

API

Die Kursdaten können über einen API-v1-Aufruf des Endpunkts /api/v1/rates/public/one abgerufen werden. Die API v1 erfordert weder eine API-Key-Autorisierung noch ein IP-Whitelisting.

Parameter	Beschreibung	Beispiel
instrumentFromCurrencyTitle	Quellwährung	BTC
instrumentFromNetworkTitle	Netzwerk der Quellwährung	BTC
instrumentToCurrencyTitle	Zielwährung	USDT
instrumentToNetworkTitle	Netzwerk der Zielwährung	TRC20
rateMode	FLOATING / FIXED	FLOATING
claimedDepositAmount	Einzahlungsbetrag	1
markup	Markup-Prozentsatz	0.3

GET /api/v1/rates/public/one
    ?instrumentFromCurrencyTitle=BTC
    &instrumentFromNetworkTitle=BTC
    &instrumentToCurrencyTitle=USDT
    &instrumentToNetworkTitle=TRC20
    &rateMode=FLOATING
    &claimedDepositAmount=1
    &markup=0.3

{
  'instrumentFrom': {
    'currencyTitle': 'BTC',
    'networkTitle': 'BTC',
    'precisionDecimals': 11
  },
  'instrumentTo': {
    'currencyTitle': 'USDT',
    'networkTitle': 'TRC20',
    'precisionDecimals': 1
  },
  'depositRules': {
    'minAmount': '0.0010202831699481001984',
    'maxAmount': '0'
  },
  'withdrawalRules': {
    'minAmount': '51.324600057525118367',
    'maxAmount': '0',
    'withdrawalFeeRules': {
      'maxAmount': '1',
      'minAmount': '1'
    }
  },
  'minConfirmationsToWithdraw': 2,
  'minConfirmationsToTrade': 2,
  'updatedAt': '2024-08-05T13:31:44.315Z',
  'liquidityProviderPublicCode': 'radio',
  'amountToGet': '50201.90689595',
  'amountToGive': '1',
  'marketMinAmount': '0.1',
  'enableFixedRate': true,
  'amountToGiveCurrencyTitle': 'BTC',
  'rateMode': 'FLOATING',
  'finalNetworkFeeAmount': '0',
  'platformFee_Absolute': null,
  'liquidityProviderQuotes': {
    'sellQuote': {
      'baseValue': '1',
      'quoteValue': '50304.27'
    },
    'buyQuote': {
      'baseValue': '50294.99',
      'quoteValue': '1'
    }
  },
  'price': '50201.90689595',
  'marketLeftPrice': '50304.27',
  'marketRightPrice': '0.000019882696069727819809',
  'marketAmountToGet': '50243.798064469251204',
  'marketAmountToGetUSDT': '50243.798064469251204',
  'quotesWithoutNetworkFee': {
    'sellQuote': {
      'baseValue': '1',
      'quoteValue': '50202.90689595'
    },
    'buyQuote': {
      'baseValue': '50294.99',
      'quoteValue': '0.997985'
    }
  },
  'quotes': {
    'sellQuote': {
      'baseValue': '1',
      'quoteValue': '50201.90689595'
    },
    'buyQuote': {
      'baseValue': '50294.99',
      'quoteValue': '0.99796512097183797717'
    }
  },
  'markup': '0.3'
}

Markup-Parameter im Order-Flow

Algorithmus

Der Markup-Parameter muss ebenfalls während der Auftragserstellung übergeben werden, um eine gültige Auftragsprovision sicherzustellen. Wenn der Markup-Parameter übergeben wird, wendet Quickex die folgende Formel auf den Provisionsalgorithmus der Order an:

A_{withdrawal} = A_{exchange} * (1 – \dfrac {(C_{platform\ (\%)} + K_{markup})}{100})

A_withdrawal	Währungsbetrag, der dem Kunden als Ergebnis des Tauschs gesendet wird
A_exchange	Währungsbetrag, der Quickex nach Ausführung unserer Handelsstrategie zur Verfügung stand
C_{platform (%)}	Von Quickex definierter Provisionsprozentsatz
K_markup	Wert des Markup-Parameters

Auf Grundlage der angegebenen Formel erhöht ein während der Auftragserstellung übergebener markup-Wert von 0,3 den Provisionsprozentsatz von Quickex um 0,3. Im folgenden Beispiel ist die Quickex-Provision auf 1 Prozent festgelegt:

A_{withdrawal} = A_{exchange} * (1 – \dfrac {1 + 0.3}{100})

Wird das vorherige Beispiel verwendet, führt ein Tausch von 1 BTC in USDT auf Basis des Marktpreises von 50243.798064469251204 BTC: USDT zum folgenden Auszahlungsbetrag für den Kunden:

50243.798064469251204 * (1 – \dfrac{1 + 0.3}{100}) = 49590.62868963115

Auf Grundlage der angegebenen Formel erhöht ein während der Auftragserstellung übergebener markup-Wert von 0,3 den Provisionsprozentsatz von Quickex um 0,3.

Nachdem ein Tausch mit einem Markup-Parameter in den Status COMPLETED übergeht, wird der Markup-Parameter in der Formel zur Berechnung der Partnermarge verwendet:

C_{affiliate} = (C_{platform} * \dfrac{C_{affiliate\ (\%)}}{100}) + (C_{platform} * \dfrac{K_{markup}}{100})

C_affiliate	Währungsbetrag, der pro Tausch an die Wallet des Affiliates gesendet wird (Affiliate-Marge)
C_platform	Währungsbetrag, den Quickex aus dem Tausch erzielt hat (Plattformmarge)
C_{affiliate (%)}	Für den Affiliate definierter Provisionsprozentsatz
K_markup	Wert des Markup-Parameters

Übergeben des Parameters `markup`

Während der Auftragserstellung akzeptiert die Quickex-API den Parameter markup zusammen mit anderen Parametern zur Auftragserstellung:

{

‘rateMode’: ‘FLOATING’,

‘instrumentFrom’: {

‘currencyTitle’: ‘USDT’,

‘networkTitle’: ‘TRC20’

},

‘instrumentTo’: {

‘currencyTitle’: ‘BTC’,

‘networkTitle’: ‘BTC’

},

‘destinationAddress’: ‘bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh’,

‘destinationAddressMemo’: null,

‘refundAddress’: null,

‘refundAddressMemo’: null,

‘claimedNetworkFee’: null,

‘legacyOrderId’: null,

‘referrerId’: ‘aff_616’,

‘claimedDepositAmount’: ‘125000’,

‘utmData’: [],

‘browserFingerprint’: ‘6b3add86bec11616427d069556a33548’,

‘markup’: ‘0.2’ // <— hier

}

Der Multiplikatorwert von markup wird zusammen mit den anderen Parametern übergeben.

Using API v2

Die Nutzung der v2-API-Endpunkte erfordert eine zusätzliche Autorisierungskonfiguration. Ohne die erforderlichen Autorisierungsparameter liefern die v2-Endpunkte einen Fehler 403 Forbidden.

Die Integration besteht aus zwei Schritten – dem Erstellen eines API-Schlüssels und der Integration seiner Verwendung in die API-Anfragen. Durch das Erstellen eines API-Schlüssels erhalten unsere B2B-Kunden ein Schlüsselpaar zum Signieren ihrer Anfragen sowie eine Liste von IP-Adressen in der Whitelist, die auf die API-Endpunkte zugreifen können.

Note:
Sie müssen ein aktives Autorisierungs-Cookie haben, um
/api/v1/users/*
Anfragen ausführen zu können.

Creating an API key

Beim Erstellen des API-Schlüssels muss ein Array von IP-Adressen in der Whitelist übergeben werden:

POST /api/v1/users/generate-api-key

Request:
{
  'name': 'test',
  'whiteListIp': ['127.0.0.1'],
  'isActive': true
}

Response:
{
  'apiId': 40,
  'name': 'test',
  'isActive': true,
  'publicKey': 'ZgzycV6Sf78BZKuyIAiz+0Bor002+0/rx1gLKsmYCsY=',
  'secretKey': 'a482a8e3a3ff9aeadefb11d3d8c11253e7e8412e05ef2b8599016cc87a64b7d6',
  'whiteListIp': [
    '127.0.0.1'
  ],
  'createdAt': '2024-08-05T13:54:18.427Z'
}

Die Antwort enthält das Schlüsselpaar, das für die Autorisierung der API v2 benötigt wird.

Note:
Das Feld
secretKey
wird nur einmal angezeigt, während der Erstellung des API-Schlüssels. Wir empfehlen, es unmittelbar nach der Erstellung des API-Schlüssels zu speichern.

Listing your API keys

Wenn Ihre Integration mehr als einen API-Schlüssel benötigt, können Sie diese einfach über den Endpunkt list auflisten:

GET /api/v1/users/list-api-key

[
  {
    'apiId': 40,
    'name': 'test',
    'isActive': true,
    'settings': {},
    'publicKey': 'ZgzycV6Sf78BZKuyIAiz+0Bor002+0/rx1gLKsmYCsY=',
    'whiteListIp': [
      '127.0.0.1'
    ],
    'createdAt': '2024-08-05T13:54:18.427Z'
  }
]

Managing your API keys

Die Verwaltung bestehender API-Schlüssel kann über unsere B2B-Kunden-Supportlinie erfolgen. Dies umfasst:

Löschen von API-Schlüsseln
Hinzufügen neuer IP-Adressen in der Whitelist zu einem bestehenden API-Schlüssel
Aktualisieren und Hinzufügen von Einstellungen für einen API-Schlüssel (z. B.: Min-/Max-Werte für den Markup-Wert)
Deaktivieren von API-Schlüsseln

Using the API key

Die API v2 erfordert drei Header, die bei jeder Anfrage gesetzt werden müssen:

Header	Wert
x-api-public-key	Ihr öffentlicher Schlüssel, der während der Erstellung des API-Schlüssels erhalten wurde
x-api-timestamp	UNIX-Zeitstempel
x-api-signature	Eine Signatur der Anfrage

Der Signaturwert wird mit hmac sha256 erzeugt. Die übergebenen Daten sind die Verkettung als Zeichenkette aus dem Zeitstempel, der String-Repräsentation des Request-Bodys und dem öffentlichen Schlüssel, während der private Schlüssel als Schlüssel für die hmac -Funktion verwendet wird:

function signRequest(requestBody) {

const timestamp = new Date().getTime();

const publicKey = ‘ZgzycV6Sf78BZKuyIAiz+0Bor002+0/rx1gLKsmYCsY=’;

const privateKey = ‘a482a8e3a3ff9aeadefb11d3d8c11253e7e8412e05ef2b8599016cc87a64b7d6’;
const encoder = new TextEncoder();

const data = encoder.encode(

timestamp + JSON.stringify(requestBody) + publicKey,

);
const hmac = createHmac(‘sha256’, privateKey);

const dataSign = hmac.update(data);

const signature = dataSign.digest(‘base64’);
return signature;

}
signRequest({ myKey: ‘myValue’ })

Beispiel-Integrationscode

Für die Python-Version siehe unser

SDK auf PyPi

const { createHmac } = require(‘crypto’);
const API_PREFIX = ‘https://quickex.io/api/’;

const PUBKEY = ‘public_key’; // changeme

const PRIVKEY = ‘private_key’; // changeme
function signRequest(requestBody, timestamp) {

const encoder = new TextEncoder();

const data = encoder.encode(timestamp + JSON.stringify(requestBody) + PUBKEY);
const hmac = createHmac(‘sha256’, PRIVKEY);

const dataSign = hmac.update(data);

const signature = dataSign.digest(‘base64’);
return signature;

}
async function createOrder() {

const clientBrowserFingerprint = ‘6b3add86bec11616427d069556a33548’;

const orderRateMode = ‘FLOATING’;

const depositAmount = ‘1’;

const clientDestinationAddress = ‘TUhw6S1HyXDhycKvTec3x7HNGQfNn3Vhpc’;

const clientDestinationAddressMemo = null;

const markup = ‘0.3’;

const instrumentFromCurrencyTitle = ‘BTC’;

const instrumentFromNetworkTitle = ‘BTC’;
const instrumentToCurrencyTitle = ‘USDT’;

const instrumentToNetworkTitle = ‘TRC20’;
// Step 1. Prepare createOrder request body using obtained rate data
const createOrderRequestBody = {

rateMode: orderRateMode,

instrumentFrom: {

currencyTitle: instrumentFromCurrencyTitle,

networkTitle: instrumentFromNetworkTitle,

},

instrumentTo: {

currencyTitle: instrumentToCurrencyTitle,

networkTitle: instrumentToNetworkTitle,

},

destinationAddress: clientDestinationAddress,

destinationAddressMemo: clientDestinationAddressMemo,

refundAddress: null,

refundAddressMemo: null,

markup: markup,

claimedNetworkFee: null,

legacyOrderId: null,

referrerId: null,

claimedDepositAmount: depositAmount,

utmData: [],

browserFingerprint: clientBrowserFingerprint,

};
// Step 2. Prepare signature based on key pair and createOrder request data
const timestamp = new Date().getTime();

const signature = signRequest(createOrderRequestBody, timestamp);
// Step 3. Call API v2 create-order endpoint
const order = JSON.parse(

await (

await fetch(`${API_PREFIX}v2/orders/public/create`, {

method: ‘POST’,

headers: {

‘x-api-public-key’: PUBKEY,

‘x-api-timestamp’: timestamp,

‘x-api-signature’: signature,

‘content-type’: ‘application/json; charset=utf-8’,

},

body: JSON.stringify(createOrderRequestBody),

})

).text(),

);
console.log(‘order’, order);

}
void createOrder();

Diesen Artikel teilen:

API-Markup