Dxtrade Python Demo

https://github.com/zleki/dxtrade-python-demo
Admin
Dxtrade Python Demo is a working demonstration of a DXTrade API client in Python, providing...
Tokens:4,012
Snippets:24
Trust Score:7.8
Update:10 months ago
Show doc for...
Tokens:
Raw
### Define Trading Instruments and Constants in Python

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

This Python snippet defines dictionaries for various trading instruments including indices and cryptocurrencies, alongside constants for order types like BUY, SELL, and MARKET price. It illustrates how to map instrument names to their respective IDs and how to access these constants for trading operations. The example also shows how to print an instrument ID.

```python
indices = {
    "US30": US30,        # 3351 (Dow Jones)
}

crypto = {
    "ETHUSD": ETHUSD,    # 3443
    "BTCUSD": BTCUSD,    # 3425
}

ORDER_SIDE_BUY = BUY      # 0
ORDER_SIDE_SELL = SELL    # 1
MARKET_PRICE = MARKET     # 0

print(f"BTCUSD Instrument ID: {BTCUSD}")
```

--------------------------------

### Initialize DXTrade Identity Client

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Initializes the DXTrade trading client with account credentials and server configuration. It requires username, password, and server details. The output confirms account ID and successful login with positions loaded.

```python
from main import Identity

# Create identity instance with credentials
identity = Identity(
    username="1210003069",
    password="your_password",
    server="ftmo"
)

# Login to establish session
identity.login()

# Output:
# Account ID: 12345678
# Login successful with positions loaded
```

--------------------------------

### WebSocket Connection Handling - Python

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Establishes a WebSocket connection to receive real-time data, specifically position updates. It includes handling the handshake, parsing JSON responses, and managing potential connection errors.

```python
from main import Identity
import json

identity = Identity("1210003069", "your_password", "ftmo")
identity.login()

# Establish WebSocket handshake and wait for specific message
try:
    response = identity.establish_handshake("POSITIONS")

    # Parse WebSocket response
    if response:
        json_str = response.split("|")[1]
        data = json.loads(json_str)

        print(f"Account ID: {data['accountId']}")
        print(f"Positions: {data['body']}")

except Exception as e:
    print(f"WebSocket connection error: {e}")

# Output:
# 200|{"accountId": 12345678, "body": [...]}
# Account ID: 12345678
# Positions: [{'positionKey': {...}, 'quantity': 0.50, ...}]
```

--------------------------------

### Place DXTrade Limit Orders

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Places limit orders for buying or selling financial instruments at a specified entry price. Users can define the quantity, take profit, and stop loss levels. The `price` parameter is used to set the limit entry price. The output shows the order payload and a success message.

```python
from main import Identity, US30, XAUUSD

identity = Identity("1210003069", "your_password", "ftmo")
identity.login()

# Buy US30 with limit order at specific price
identity.buy(
    quantity=0.10,
    tp=35000,          # Take profit
    sl=33500,          # Stop loss
    price=34000,       # Limit entry price
    symbol="US30",
    instrument_id=US30
)

# Sell gold (XAUUSD) with limit order
identity.sell(
    quantity=0.50,
    tp=1950,
    sl=2050,
    price=2000,        # Enter when price reaches 2000
    symbol="XAUUSD",
    instrument_id=XAUUSD
)

# Output:
# PAYLOAD {'directExchange': False, 'orderType': 'LIMIT', 'limitPrice': 34000, ...}
# Order executed successfully!
```

--------------------------------

### Authenticate DXTrade Login

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Authenticates with the DXTrade platform to establish a trading session. This process involves sending credentials, obtaining a CSRF token, and loading existing positions. It outputs the account ID, CSRF token, and session cookies upon successful authentication.

```python
import requests
from main import Identity

identity = Identity("1210003069", "your_password", "ftmo")

# Perform login - establishes session, fetches CSRF token, and loads positions
identity.login()

# Access session data after successful login
print(f"Account ID: {identity.account_id}")
print(f"CSRF Token: {identity.csrf}")
print(f"Session Cookies: {identity.cookies}")

# Output:
# Account ID: 12345678
# CSRF Token: a1b2c3d4-e5f6-7890-abcd-ef1234567890
# Session Cookies: {'DXTFID': '4a5c1792438ca392', 'JSESSIONID': 'D158AB6886F36A59CEFB4FE770D215EF.jvmroute'}
```

--------------------------------

### Trade Multiple Instruments - Python

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Demonstrates executing buy and sell orders for various financial instruments including forex pairs, commodities, indices, and cryptocurrencies. It utilizes market orders and specifies trade parameters like volume and price levels.

```python
from main import Identity, GBPUSD, EURUSD, USDJPY, XAUUSD, US30, BTCUSD, ETHUSD, MARKET

identity = Identity("1210003069", "your_password", "ftmo")
identity.login()

# Trade forex pairs
identity.buy(1.0, 0, 0, MARKET, "GBPUSD", GBPUSD)
identity.buy(1.0, 0, 0, MARKET, "EURUSD", EURUSD)
identity.sell(1.0, 0, 0, MARKET, "USDJPY", USDJPY)

# Trade commodities
identity.buy(0.10, 2100, 1950, MARKET, "XAUUSD", XAUUSD)  # Gold

# Trade indices
identity.buy(0.50, 35000, 33500, MARKET, "US30", US30)    # Dow Jones

# Trade cryptocurrencies
identity.buy(0.05, 50000, 38000, MARKET, "BTCUSD", BTCUSD)
identity.buy(0.50, 3000, 2500, MARKET, "ETHUSD", ETHUSD)

# Output:
# Order executed successfully! (for each trade)
```

--------------------------------

### Execute DXTrade Buy Market Order

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Executes a buy market order for a specified quantity of a financial instrument. Optional take profit (tp) and stop loss (sl) prices can be provided. The `price` parameter should be set to `MARKET` for immediate execution at the current market price. Outputs the order payload and a success message.

```python
from main import Identity, BTCUSD, US30, XAUUSD, MARKET

identity = Identity("1210003069", "your_password", "ftmo")
identity.login()

# Buy 0.50 lots of BTCUSD at market price
identity.buy(
    quantity=0.50,
    tp=0,          # Take profit price (0 = no TP)
    sl=0,          # Stop loss price (0 = no SL)
    price=MARKET,  # MARKET = 0 for market execution
    symbol="BTCUSD",
    instrument_id=BTCUSD
)

# Buy with take profit and stop loss
identity.buy(
    quantity=1.0,
    tp=45000,      # Take profit at 45000
    sl=38000,      # Stop loss at 38000
    price=MARKET,
    symbol="BTCUSD",
    instrument_id=BTCUSD
)

# Output:
# PAYLOAD {'directExchange': False, 'legs': [{'instrumentId': 3425, 'positionEffect': 'OPENING', ...}]}
# Order executed successfully!
```

--------------------------------

### Retrieve DXTrade Open Positions

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Fetches and returns a list of all currently open trading positions for the authenticated account. This function is essential for monitoring active trades and managing risk. Requires a successful login prior to execution.

```python
from main import Identity

identity = Identity("1210003069", "your_password", "ftmo")
identity.login()

# Fetch current positions
positions = identity.get_positions()

```

--------------------------------

### CSRF Token Management - Python

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Explains how to fetch and manage Cross-Site Request Forgery (CSRF) tokens, which are essential for secure API interactions. The token is automatically obtained upon login and can be accessed or refreshed manually.

```python
from main import Identity
from bs4 import BeautifulSoup

identity = Identity("1210003069", "your_password", "ftmo")

# Login automatically fetches CSRF token
identity.login()

# Access CSRF token for custom requests
csrf_token = identity.csrf
print(f"Current CSRF Token: {csrf_token}")

# Manually refresh CSRF token if needed
new_csrf = identity.fetch_csrf()
print(f"Refreshed CSRF Token: {new_csrf}")

# CSRF token is automatically included in all trading requests
# Output:
# Current CSRF Token: a1b2c3d4-e5f6-7890-abcd-ef1234567890
# Refreshed CSRF Token: a1b2c3d4-e5f6-7890-abcd-ef1234567890
```

--------------------------------

### Process Position Data - Python

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Iterates through a list of positions and prints details for each, such as position ID, symbol, quantity, instrument ID, and profit/loss. It handles cases where P&L might not be available.

```python
for position in positions:
    print(f"Position ID: {position['positionKey']['positionCode']}")
    print(f"Symbol: {position['positionKey']['positionCode']}")
    print(f"Quantity: {position['quantity']}")
    print(f"Instrument ID: {position['positionKey']['instrumentId']}")
    print(f"P&L: {position.get('profitLoss', 'N/A')}")
    print("---")
```

--------------------------------

### Execute DXTrade Sell Market Order

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Executes a sell market order for a specified quantity of a financial instrument. Supports setting optional take profit (tp) and stop loss (sl) prices. Use `MARKET` for the `price` parameter to execute at the current market price. The output includes the order payload and confirmation of successful execution.

```python
from main import Identity, EURUSD, GBPUSD, MARKET

identity = Identity("1210003069", "your_password", "ftmo")
identity.login()

# Sell 1.0 lot of EURUSD at market price
identity.sell(
    quantity=1.0,
    tp=0,
    sl=0,
    price=MARKET,
    symbol="EURUSD",
    instrument_id=EURUSD
)

# Sell GBPUSD with stop loss protection
identity.sell(
    quantity=2.0,
    tp=1.2500,     # Take profit at 1.2500
    sl=1.2800,     # Stop loss at 1.2800
    price=MARKET,
    symbol="GBPUSD",
    instrument_id=GBPUSD
)

# Output:
# PAYLOAD {'directExchange': False, 'legs': [{'instrumentId': 3438, ...}], 'orderSide': 'SELL'}
# Order executed successfully!
```

--------------------------------

### Available Instrument IDs - Python

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Lists and maps common trading instruments, including forex pairs, commodities, and cryptocurrencies, to their corresponding integer IDs used within the DXtrade platform. This is useful for referencing instruments in trading functions.

```python
from main import (
    GBPUSD, EURUSD, USDJPY, EURGBP, USDCAD, USDCHF,
    AUDUSD, NZDUSD, EURJPY, AUDCHF, XAUUSD, US30,
    ETHUSD, BTCUSD, BUY, SELL, MARKET
)

# Forex pairs
forex_instruments = {
    "GBPUSD": GBPUSD,    # 3440
    "EURUSD": EURUSD,    # 3438
    "USDJPY": USDJPY,    # 3427
    "EURGBP": EURGBP,    # 3419
    "USDCAD": USDCAD,    # 3433
    "USDCHF": USDCHF,    # 3390
    "AUDUSD": AUDUSD,    # 3411
    "NZDUSD": NZDUSD,    # 3398
    "EURJPY": EURJPY,    # 3392
    "AUDCHF": AUDCHF,    # 3395
}

# Commodities
commodities = {
    "XAUUSD": XAUUSD,    # 3406 (Gold)
}

```

--------------------------------

### Close Specific Position - Python

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Demonstrates how to close a specific open position using its position ID and quantity. It shows closing at market price and with a limit price. Requires prior login and fetching of current positions.

```python
from main import Identity, BTCUSD

identity = Identity("1210003069", "your_password", "ftmo")
identity.login()

# Get positions to find position codes
positions = identity.get_positions()

if positions:
    position = positions[0]

    # Close specific position at market
    identity.close_trade(
        position_id=position["positionKey"]["positionCode"],
        quantity=position["quantity"],
        price=0,  # 0 = market price
        symbol=position["positionKey"]["positionCode"],
        instrument_id=position["positionKey"]["instrumentId"]
    )

    print(f"Closed position: {position['positionKey']['positionCode']}")

# Close with limit price
identity.close_trade(
    position_id="POS123456",
    quantity=0.50,
    price=42000,  # Close at limit price
    symbol="BTCUSD",
    instrument_id=BTCUSD
)
```

--------------------------------

### Close All Positions - Python

Source: https://context7.com/zleki/dxtrade-python-demo/llms.txt

Provides a simple method to close all open positions in the trading account simultaneously at market price. It requires the user to be logged in.

```python
from main import Identity

identity = Identity("1210003069", "your_password", "ftmo")
identity.login()

# Close all open positions at market price
identity.close_all()

# The method iterates through all positions and closes them
# Output:
# Closing position POS123456 for BTCUSD
# Closing position POS123457 for EURUSD
# Closing position POS123458 for US30
# All positions closed successfully
```
Tokens:
Raw