API Integration & Examples

This section outlines how to integrate with the QE API and provides examples of API usage.

1. Integration Process

For institutional users or developers, the process of integrating with QE’s API generally involves:

1. Obtain API Credentials: Contact the QuantumExecute team to obtain your unique Client ID and API Secret for API access. These credentials are used to identify your application and to sign requests. (In the platform UI, this corresponds to creating a “Strategy API” key in your account settings, which will provide the Key/Secret pair).

2. IP Whitelisting: Coordinate with QE support to register the IP address(es) from which your API requests will originate. For security, QE’s API gateway will only accept requests from known client IPs. If your systems’ IPs change or if you need to add more, inform the QE team to update the whitelist.

3. Exchange API Setup: Ensure you have linked at least one exchange account via API (as described in Account Management). If you’re using the API integration in a server-to-server fashion rather than through the UI, you might need to supply the exchange API keys via a secure method. Typically, you will have added them in the UI already. In some enterprise setups, clients encrypt their exchange API Secret with QE’s public key and send it to QE for configuration – this step ensures that even out-of-band transfer of sensitive info is secure. Once configured, QE will have your exchange connection ready to go for API-triggered orders.

4. Follow the API Documentation: With credentials in hand and accounts linked, utilize the QE API endpoints to execute strategies. All API calls must be properly authenticated – this usually means adding a timestamp, your Client ID, and a signature (HMAC-SHA256 of the request data using your API Secret) in the request header or payload. Refer to QE’s API docs for the exact format and required parameters (the docs are available from QE upon request).

After this setup, you can programmatically do things like: start an algorithmic order, check order status, cancel an order, retrieve TCA reports, etc., through HTTP API calls.

2. Example API Usage

Below is a conceptual example of starting a TWAP algorithm via a hypothetical REST API call using Python (for illustration):

import time, hmac, hashlib
import requests

# Credentials (obtained from QE)
CLIENT_ID = "your_client_id"
API_SECRET = b"your_api_secret_bytes"  # ensure this is in bytes for HMAC

# Example order parameters
payload = {
    "exchange": "Binance",
    "symbol": "BTCUSDT",
    "side": "buy",
    "strategy": "TWAP",
    "order_quantity": 100,       # total quantity to buy
    "duration": 3600,            # execution duration in seconds (e.g., 1 hour)
    "start_time": int(time.time())  # start now (current epoch time)
    # ... other optional parameters like price limits, etc.
}
# Convert payload to JSON string
import json
body = json.dumps(payload)

# Prepare authentication headers
timestamp = str(int(time.time() * 1000))  # current timestamp in ms
# Create signature: HMAC_SHA256(secret, <timestamp + body>)
signing_payload = (timestamp + body).encode('utf-8')
signature = hmac.new(API_SECRET, signing_payload, hashlib.sha256).hexdigest()

headers = {
    "X-QE-CLIENTID": CLIENT_ID,
    "X-QE-TIMESTAMP": timestamp,
    "X-QE-SIGNATURE": signature,
    "Content-Type": "application/json"
}

# Send request (assuming endpoint URL and path)
url = "https://api.quantumexecute.com/v1/algo_order"
response = requests.post(url, data=body, headers=headers)
res_data = response.json()
print("Order Status:", res_data)

In this pseudo-code:

• We construct a JSON payload with order details (what to trade, which strategy, etc.).

• We then create an HMAC SHA256 signature using the API Secret. The signature in this example is computed over a string that concatenates a timestamp and the request body (the exact method may vary; consult the docs for the correct signing method).

• We include the ClientID, Timestamp, and Signature in the headers as required by the API.

• Finally, we make an HTTP POST to the QE API endpoint (the URL and path here are illustrative) to initiate the algo order.

The response would typically include an order identifier or status indicating the algo has started (or an error message if something was wrong).

Alternatively, QE provides official client libraries in Go and Python to abstract away some of this work. Using those libraries, the above process might be as simple as calling a function to create the order with your credentials configured, without manually handling the signature.

3. Important Notes

• Time Synchronization: Ensure your system clock is accurate (preferably synced via NTP). The API’s timestamp tolerance might be strict (for example, the request timestamp may need to be within a few seconds of the server time) to prevent replay attacks, so an out-of-sync clock can lead to authentication failures.

• Error Handling: When using the API, handle common errors gracefully. For instance, if you receive an HTTP 401 error, check your signature and credentials; a 429 error might indicate rate limiting (slow down your request frequency). The API will provide error codes/messages for guidance (e.g., “INVALID_SIGNATURE”, “RATE_LIMIT_EXCEEDED”, “INSUFFICIENT_FUNDS” if the exchange rejects an order due to lack of balance, etc.). Implement retries or fallbacks as appropriate.

• Testing: Use the sandbox or test environment if available. QE’s test environment (test.quantumexecute.com) might allow API testing without real funds. Always test your API integration with small orders or in simulation mode before scaling up to large live orders.

• Security: Never expose your API Secret in client-side code (like browser JS) or in unsecured logs. Treat it like a password. If you suspect it’s compromised, rotate the key (delete and create a new one via the platform). Also, use the IP whitelist feature – since QE will enforce it, ensure you’re calling from the correct server.

By following the API documentation and the above guidelines, you can seamlessly integrate QE’s powerful execution algorithms into your own trading workflows, gaining programmatic control over strategy deployment.

For full API endpoint details and advanced integration topics, please refer to the official QuantumExecute API Documentation or contact our technical support.