Dxtrade API

https://github.com/zleki/dxtrade-api-go
Admin
A usable Go API for Dxtrade, providing functionalities like executing buy/sell orders, managing...
Tokens:6,340
Snippets:35
Trust Score:7.8
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Get Current Positions

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Retrieves all currently open positions with detailed information, including position keys, quantities, costs, and margin rates.

```APIDOC
## Get Current Positions

### Description
Retrieves all open positions with details including quantity, cost, and position keys.

### Method
GET (Implied by data retrieval)

### Endpoint
/api/positions (Hypothetical, as Go library abstracts this)

### Parameters
None

### Request Example
```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    positions := identity.GetTransactions()
    for _, position := range positions.Body {
        fmt.Printf("Position: %s\n", position.PositionKey.PositionCode)
        fmt.Printf("Instrument ID: %d\n", position.PositionKey.InstrumentId)
        fmt.Printf("Quantity: %.2f\n", position.Quantity)
        fmt.Printf("Cost: %.2f\n", position.Cost)
        fmt.Printf("Margin Rate: %.4f\n", position.MarginRate)
    }
}
```

### Response
#### Success Response (200)
- **Body** (array) - An array of position objects.
  - **PositionKey** (object) - Unique identifier for the position.
    - **PositionCode** (string) - The code representing the position.
    - **InstrumentId** (int) - The ID of the instrument.
  - **Quantity** (float64) - The current quantity of the position.
  - **Cost** (float64) - The cost basis of the position.
  - **MarginRate** (float64) - The margin rate for the position.
- **Status** (string) - "success" or "error"

#### Response Example
```json
{
  "Body": [
    {
      "PositionKey": {
        "PositionCode": "BUY-12345",
        "InstrumentId": 1
      },
      "Quantity": 1000.0,
      "Cost": 100000.0,
      "MarginRate": 0.01
    }
  ],
  "Status": "success"
}
```
```

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

### Get Available Instruments with Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Retrieves a comprehensive list of all tradable instruments available on the platform using the DxTrade Go API. It includes details like symbol, description, currency, price increment, quantity increment, and initial margin requirements for each instrument.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    instruments := identity.GetInstruments()
    if instruments != nil {
        for _, instrument := range instruments.Body {
            fmt.Printf("Symbol: %s\n", instrument.Symbol)
            fmt.Printf("Description: %s\n", instrument.Description)
            fmt.Printf("Type: %s, Subtype: %s\n", instrument.Type, instrument.Subtype)
            fmt.Printf("Currency: %s\n", instrument.Currency)
            fmt.Printf("Price Increment: %.5f\n", instrument.PriceIncrement)
            fmt.Printf("Quantity Increment: %.5f\n", instrument.QuantityIncrement)
            fmt.Printf("Initial Margin: %s\n", instrument.InitialMargin)
            fmt.Println("---")
        }
    }
}
```

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

### Get Position Metrics with Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Fetches detailed metrics for all open positions, including margin usage, profit/loss, and trading rates, via the DxTrade Go API. This function requires authentication and iterates through the returned position data, printing key financial details for each.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    posMetrics := identity.PositionMetrix()
    if posMetrics != nil {
        for _, metric := range posMetrics.Body {
            fmt.Printf("Position UID: %s\n", metric.Uid)
            fmt.Printf("Margin: %.2f\n", metric.Margin)
            fmt.Printf("Open P/L: %.2f\n", metric.PlOpen)
            fmt.Printf("P/L Rate: %.4f\n", metric.PlRate)
        }
    }
}
```

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

### Get Open Orders with Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Fetches all pending orders currently active on the trading account via the DxTrade Go API. The output includes order ID, status, type, quantity, remaining quantity, and time in force for each order.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    orders := identity.GetOrders()
    if orders != nil {
        for _, order := range orders.Body {
            fmt.Printf("Order ID: %d\n", order.OrderId)
            fmt.Printf("Status: %s\n", order.Status)
            fmt.Printf("Type: %s\n", order.Type)
            fmt.Printf("Quantity: %.2f\n", order.Quantity)
            fmt.Printf("Remaining: %.2f\n", order.RemainingQuantity)
            fmt.Printf("Time in Force: %s\n", order.TimeInForce)
        }
    }
}
```

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

### Go: Get Current Positions from DxTrade API

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Retrieves all currently open positions associated with the authenticated trading account. The output includes detailed information for each position, such as its key, instrument ID, quantity, cost, and margin rate. Requires an active session. Dependencies include the DxTrade-Api-Go library.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    positions := identity.GetTransactions()
    for _, position := range positions.Body {
        fmt.Printf("Position: %s\n", position.PositionKey.PositionCode)
        fmt.Printf("Instrument ID: %d\n", position.PositionKey.InstrumentId)
        fmt.Printf("Quantity: %.2f\n", position.Quantity)
        fmt.Printf("Cost: %.2f\n", position.Cost)
        fmt.Printf("Margin Rate: %.4f\n", position.MarginRate)
    }
}
```

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

### Get Account Metrics with Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Retrieves key account financial metrics such as available funds, equity, margin, and risk level using the DxTrade Go API. This function requires an authenticated identity and returns a structured object containing various account performance indicators.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    accountData := identity.GetAccountMetrix()
    if accountData != nil {
        metrics := accountData.Body.AllMetrics
        fmt.Printf("Available Funds: %.2f\n", metrics.AvailableFunds)
        fmt.Printf("Equity: %.2f\n", metrics.Equity)
        fmt.Printf("Cash Balance: %.2f\n", metrics.CashBalance)
        fmt.Printf("Open P/L: %.2f\n", metrics.OpenPl)
        fmt.Printf("Initial Margin: %.2f\n", metrics.InitialMargin)
        fmt.Printf("Risk Level: %.4f\n", metrics.RiskLevel)
    }
}
```

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

### Get Candlestick Chart Data using DxTrade API Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

This Go code retrieves historical candlestick OHLCV (Open, High, Low, Close, Volume) data for technical analysis from DxTrade. It requires the DxTrade-Api-Go library and allows for processing of market data.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    data := identity.GetCandleStickData("USDJPY")
    if data != nil {
        fmt.Printf("Total candles: %d\n", len(data.Body.Data))

        // Print first 5 candles
        for i := 0; i < 5 && i < len(data.Body.Data); i++ {
            candle := data.Body.Data[i]
            fmt.Printf("Timestamp: %d\n", candle.Timestamp)
            fmt.Printf("Open: %.5f, High: %.5f, Low: %.5f, Close: %.5f\n",
                candle.Open, candle.High, candle.Low, candle.Close)
            fmt.Printf("Volume: %d, VWAP: %.5f\n", candle.Volume, candle.Vwap)
            fmt.Println("---")
        }
    }
}
```

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

### Go: Execute Buy Order on DxTrade API

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Places buy orders on the DxTrade platform, supporting both market and limit orders. It allows specifying quantity, price (for limit orders), optional take-profit and stop-loss levels, and the instrument. Requires an active session established via `identity.Login()`. Dependencies include the DxTrade-Api-Go library.

```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    // Market order: 1500 units at market price
    identity.Buy(1500, dx.MARKET, 0, 0, "USDJPY", dx.USDJPY)

    // Limit order: 0.1 BTC at $30000 with TP at $35000 and SL at $28000
    identity.Buy(0.1, 30000.0, 35000.0, 28000.0, "BTCUSD", dx.BTCUSD)
}
```

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

### Go: Execute Sell Order on DxTrade API

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Places sell orders on the DxTrade platform, supporting both market and limit orders. It allows specifying quantity, price (for limit orders), optional take-profit and stop-loss levels, and the instrument. Requires an active session established via `identity.Login()`. Dependencies include the DxTrade-Api-Go library.

```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    // Market sell: 1000 units at market price
    identity.Sell(1000, dx.MARKET, 0, 0, "EURUSD", dx.EURUSD)

    // Limit sell: 2 lots gold at $1950 with TP at $1900 and SL at $1980
    identity.Sell(2, 1950.0, 1900.0, 1980.0, "XAUUSD", dx.XAUUSD)
}
```

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

### Execute Buy Order

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Places a market or limit buy order for a specified instrument. Supports optional take-profit and stop-loss levels.

```APIDOC
## Execute Buy Order

### Description
Places a market or limit buy order with optional take-profit and stop-loss levels.

### Method
POST (Implied by order execution)

### Endpoint
/api/order/buy (Hypothetical, as Go library abstracts this)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **quantity** (float64) - Required - The amount to buy (units for forex/commodities, lots for others).
- **orderType** (string) - Required - Type of order: `dx.MARKET` or a price for limit orders.
- **takeProfit** (float64) - Optional - Take profit price level. Use 0 if not applicable.
- **stopLoss** (float64) - Optional - Stop loss price level. Use 0 if not applicable.
- **instrumentName** (string) - Required - The name of the instrument (e.g., "USDJPY").
- **instrumentId** (int) - Required - The ID of the instrument.

### Request Example
```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    // Market order: 1500 units at market price
    identity.Buy(1500, dx.MARKET, 0, 0, "USDJPY", dx.USDJPY)

    // Limit order: 0.1 BTC at $30000 with TP at $35000 and SL at $28000
    identity.Buy(0.1, 30000.0, 35000.0, 28000.0, "BTCUSD", dx.BTCUSD)
}
```

### Response
#### Success Response (200)
- **OrderID** (string) - Unique identifier for the placed order.
- **Status** (string) - "success" or "error"

#### Response Example
(Order confirmation details are typically returned by the library)
```

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

### Login Authentication

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Authenticates with the DxTrade server and establishes a trading session, storing cookies and CSRF tokens for subsequent requests.

```APIDOC
## Login Authentication

### Description
Authenticates with the DxTrade server and establishes a trading session with cookies and CSRF tokens.

### Method
POST (Implied by login action)

### Endpoint
/api/login (Hypothetical, as Go library abstracts this)

### Parameters
#### Request Body
- **identity** (object) - Required - Authentication credentials.
  - **Username** (string) - Required - Your DxTrade username.
  - **Password** (string) - Required - Your DxTrade password.
  - **Server** (string) - Required - The DxTrade server to connect to (e.g., "ftmo").

### Request Example
```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()
    // Session established with cookies stored in identity.Cookies
}
```

### Response
#### Success Response (200)
- **Cookies** (map[string]string) - Session cookies and CSRF tokens.
- **Status** (string) - "success" or "error"

#### Response Example
(Session details are typically stored internally by the library)
```

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

### Go: Authenticate with DxTrade API

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Establishes a trading session with the DxTrade server using provided credentials. It handles authentication and stores session cookies and CSRF tokens within the identity object for subsequent API calls. Dependencies include the DxTrade-Api-Go library.

```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()
    // Session established with cookies stored in identity.Cookies
}
```

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

### Partially Close Position with Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Demonstrates how to close a fraction of an existing position using the DxTrade Go API. It requires authenticated identity and retrieves existing positions to partially close a specified quantity. The function returns an error if the operation fails.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    positions := identity.GetTransactions()
    if len(positions.Body) > 0 {
        pos := positions.Body[0]
        // Close 50% of the position
        partialQty := pos.Quantity / 2
        err := identity.PartialClose(
            pos.PositionKey.InstrumentId,
            pos.PositionKey.PositionCode,
            "USDJPY",
            partialQty,
        )
        if err != nil {
            fmt.Println("Error:", err)
        } else {
            fmt.Println("Partially closed position")
        }
    }
}
```

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

### Execute Sell Order

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Places a market or limit sell order for a specified instrument. Supports optional take-profit and stop-loss levels.

```APIDOC
## Execute Sell Order

### Description
Places a market or limit sell order with optional take-profit and stop-loss levels.

### Method
POST (Implied by order execution)

### Endpoint
/api/order/sell (Hypothetical, as Go library abstracts this)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **quantity** (float64) - Required - The amount to sell (units for forex/commodities, lots for others).
- **orderType** (string) - Required - Type of order: `dx.MARKET` or a price for limit orders.
- **takeProfit** (float64) - Optional - Take profit price level. Use 0 if not applicable.
- **stopLoss** (float64) - Optional - Stop loss price level. Use 0 if not applicable.
- **instrumentName** (string) - Required - The name of the instrument (e.g., "EURUSD").
- **instrumentId** (int) - Required - The ID of the instrument.

### Request Example
```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    // Market sell: 1000 units at market price
    identity.Sell(1000, dx.MARKET, 0, 0, "EURUSD", dx.EURUSD)

    // Limit sell: 2 lots gold at $1950 with TP at $1900 and SL at $1980
    identity.Sell(2, 1950.0, 1900.0, 1980.0, "XAUUSD", dx.XAUUSD)
}
```

### Response
#### Success Response (200)
- **OrderID** (string) - Unique identifier for the placed order.
- **Status** (string) - "success" or "error"

#### Response Example
(Order confirmation details are typically returned by the library)
```

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

### Access Instrument Constants with DxTrade API Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

This Go snippet shows how to access predefined instrument IDs for various trading pairs available on DxTrade. It utilizes constants provided by the DxTrade-Api-Go library for major forex pairs, cryptocurrencies, indices, commodities, and stocks.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    // Major Forex Pairs
    fmt.Println("EUR/USD ID:", dx.EURUSD)
    fmt.Println("USD/JPY ID:", dx.USDJPY)
    fmt.Println("GBP/USD ID:", dx.GBPUSD)

    // Cryptocurrencies
    fmt.Println("BTC/USD ID:", dx.BTCUSD)
    fmt.Println("ETH/USD ID:", dx.ETHUSD)
    fmt.Println("XRP/USD ID:", dx.XRPUSD)

    // Indices
    fmt.Println("US30 Cash ID:", dx.US30CASH)
    fmt.Println("US100 Cash ID:", dx.US100CASH)
    fmt.Println("US500 Cash ID:", dx.US500CASH)

    // Commodities
    fmt.Println("Gold (XAU/USD) ID:", dx.XAUUSD)
    fmt.Println("Silver (XAG/USD) ID:", dx.XAGUSD)
    fmt.Println("Oil (US) ID:", dx.USOILCASH)

    // Stocks
    fmt.Println("Apple ID:", dx.AAPL)
    fmt.Println("Tesla ID:", dx.TSLA)
    fmt.Println("Microsoft ID:", dx.MSFT)
}
```

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

### Close All Positions

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Closes all currently open positions across all instruments in a single, atomic operation.

```APIDOC
## Close All Positions

### Description
Closes all open positions in a single operation.

### Method
POST (Implied by closing action)

### Endpoint
/api/positions/closeall (Hypothetical, as Go library abstracts this)

### Parameters
None

### Request Example
```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    // Close all open positions immediately
    identity.CloseAllPositions()
}
```

### Response
#### Success Response (200)
- **Status** (string) - "success" or "error"
- **Message** (string) - Confirmation message, e.g., "All positions closed successfully."

#### Response Example
```json
{
  "Status": "success",
  "Message": "All positions closed successfully."
}
```
```

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

### Retrieve Trade History with DxTrade API Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

This Go function retrieves the trade history for the last 5 days, including executed orders and profit/loss data, from the DxTrade platform. It uses the DxTrade-Api-Go library and prints details for each trade.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    history := identity.TradeHistory()
    for _, trade := range history {
        fmt.Printf("Order Chain ID: %s\n", trade.OrderChainId)
        fmt.Printf("Symbol: %s\n", trade.Symbol)
        fmt.Printf("Status: %s\n", trade.Status)
        fmt.Printf("Quantity: %.2f\n", trade.Quantity)
        fmt.Printf("Side: %s\n", trade.Side)
        fmt.Printf("Type: %s\n", trade.Type)
        fmt.Printf("Instrument: %s - %s\n", trade.Instrument.Symbol, trade.Instrument.Description)
        fmt.Println("---")
    }
}
```

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

### Cancel All Pending Orders using DxTrade API Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

This Go code snippet demonstrates how to cancel all pending orders in a DxTrade account. It requires the DxTrade-Api-Go library and involves authenticating with user credentials before calling the CancelAllOrders method.

```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    // Cancel all pending orders
    identity.CancelAllOrders()
}
```

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

### Go: Close All Positions on DxTrade API

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Immediately closes all currently open positions for the authenticated trading account in a single operation. This is a convenient function for clearing all trades. Requires an active session. Dependencies include the DxTrade-Api-Go library.

```go
package main

import "github.com/zLeki/DxTrade-Api-Go"

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    // Close all open positions immediately
    identity.CloseAllPositions()
}
```

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

### Cancel Order with Go

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Demonstrates how to cancel a specific pending order using its unique order ID with the DxTrade Go API. This function requires an authenticated identity and the ID of the order to be cancelled. It returns a boolean indicating success or failure.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    orderId := 12345
    success := identity.CancelOrder(orderId)
    if success {
        fmt.Println("Order cancelled successfully")
    } else {
        fmt.Println("Failed to cancel order")
    }
}
```

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

### Close Specific Position

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Closes a single, specific open position identified by its position code and instrument ID.

```APIDOC
## Close Specific Position

### Description
Closes a single position by position code and instrument ID.

### Method
POST (Implied by closing action)

### Endpoint
/api/position/close (Hypothetical, as Go library abstracts this)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **positionCode** (string) - Required - The code of the position to close.
- **quantity** (float64) - Required - The quantity to close (use the full quantity to close the entire position).
- **price** (float64) - Optional - The price at which to close the position. Use 0 for market close.
- **orderCode** (string) - Required - Typically the same as `positionCode`.
- **instrumentId** (int) - Required - The ID of the instrument associated with the position.

### Request Example
```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    positions := identity.GetTransactions()
    for _, v := range positions.Body {
        if v.Quantity > 0 {
            fmt.Println("Closing buy position with quantity:", v.Quantity)
            identity.ClosePosition(
                v.PositionKey.PositionCode,
                v.Quantity,
                0, // Market close
                v.PositionKey.PositionCode,
                v.PositionKey.InstrumentId,
            )
        }
    }
}
```

### Response
#### Success Response (200)
- **CloseOrderID** (string) - Identifier for the closing order.
- **Status** (string) - "success" or "error"

#### Response Example
(Confirmation of position closure is typically handled by the library)
```

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

### Go: Close Specific Position on DxTrade API

Source: https://context7.com/zleki/dxtrade-api-go/llms.txt

Closes a single, specific open position identified by its position code and instrument ID. This function iterates through existing positions and allows for targeted closure. Requires an active session and prior retrieval of position details. Dependencies include the DxTrade-Api-Go library.

```go
package main

import (
    "fmt"
    "github.com/zLeki/DxTrade-Api-Go"
)

func main() {
    identity := dx.Identity{
        Username: "your_username",
        Password: "your_password",
        Server:   "ftmo",
    }
    identity.Login()

    positions := identity.GetTransactions()
    for _, v := range positions.Body {
        if v.Quantity > 0 {
            fmt.Println("Closing buy position with quantity:", v.Quantity)
            identity.ClosePosition(
                v.PositionKey.PositionCode,
                v.Quantity,
                0,
                v.PositionKey.PositionCode,
                v.PositionKey.InstrumentId,
            )
        }
    }
}
```
Tokens:
Raw