Manage Trading Accounts

List, enable, disable, and disconnect your trading accounts.

List Trading Accounts

Retrieve all connected trading accounts:

Python
TypeScript
Go

response = trading_account_api.list_trading_accounts()
accounts = response.data

for account in accounts:
    print(f"{account.trading_account_id}")
    print(f"  Venue: {account.venue}")
    print(f"  Type: {account.account_type}")
    print(f"  Status: {account.status}")
    print(f"  Nickname: {account.nickname}")

const response = await tradingAccountApi.listTradingAccounts()
const accounts = response.data.data

accounts.forEach(account => {
  console.log(account.tradingAccountId)
  console.log(`  Venue: ${account.venue}`)
  console.log(`  Type: ${account.accountType}`)
  console.log(`  Status: ${account.status}`)
  console.log(`  Nickname: ${account.nickname}`)
})

response, _, err := apiClient.TradingAccountAPI.ListTradingAccounts(ctx).Execute()
if err != nil {
    panic(err)
}

for _, account := range response.Data {
    fmt.Println(*account.TradingAccountId)
    fmt.Printf("  Venue: %s\n", *account.Venue)
    fmt.Printf("  Type: %s\n", *account.AccountType)
    fmt.Printf("  Status: %s\n", *account.Status)
    fmt.Printf("  Nickname: %s\n", *account.Nickname)
}

Filter by Venue

Python
TypeScript
Go

response = trading_account_api.list_trading_accounts(
    venue=cadenza_client.Venue.BINANCE
)

const response = await tradingAccountApi.listTradingAccounts(
  undefined,   // tradingAccountId
  undefined,   // tradingAccountIds
  'BINANCE'    // venue
)

venue := client.VENUE_BINANCE
response, _, err := apiClient.TradingAccountAPI.ListTradingAccounts(ctx).
    Venue(venue).
    Execute()

Filter by Status

Python
TypeScript
Go

response = trading_account_api.list_trading_accounts(
    status=cadenza_client.TradingAccountStatus.CONNECTED
)

const response = await tradingAccountApi.listTradingAccounts(
  undefined,    // tradingAccountId
  undefined,    // tradingAccountIds
  undefined,    // venue
  'CONNECTED'   // status
)

status := client.TRADINGACCOUNTSTATUS_CONNECTED
response, _, err := apiClient.TradingAccountAPI.ListTradingAccounts(ctx).
    Status(status).
    Execute()

Enable Trading Account

Enable a disabled trading account to resume trading:

Python
TypeScript
Go

response = trading_account_api.enable_trading_account(
    cadenza_client.EnableTradingAccountRequest(
        trading_account_id=trading_account_id
    )
)

account = response.data
print(f"Status: {account.status}")  # ENABLED

const response = await tradingAccountApi.enableTradingAccount({
  tradingAccountId: tradingAccountId,
})

const account = response.data.data
console.log('Status:', account.status)  // ENABLED

response, _, err := apiClient.TradingAccountAPI.EnableTradingAccount(ctx).
    EnableTradingAccountRequest(client.EnableTradingAccountRequest{
        TradingAccountId: tradingAccountId,
    }).Execute()
if err != nil {
    panic(err)
}

account := response.Data
fmt.Printf("Status: %s\n", *account.Status)  // ENABLED

Disable Trading Account

Temporarily disable a trading account. This prevents new orders but doesn't affect existing positions:

Python
TypeScript
Go

response = trading_account_api.disable_trading_account(
    cadenza_client.DisableTradingAccountRequest(
        trading_account_id=trading_account_id
    )
)

account = response.data
print(f"Status: {account.status}")  # DISABLED

const response = await tradingAccountApi.disableTradingAccount({
  tradingAccountId: tradingAccountId,
})

const account = response.data.data
console.log('Status:', account.status)  // DISABLED

response, _, err := apiClient.TradingAccountAPI.DisableTradingAccount(ctx).
    DisableTradingAccountRequest(client.DisableTradingAccountRequest{
        TradingAccountId: tradingAccountId,
    }).Execute()
if err != nil {
    panic(err)
}

account := response.Data
fmt.Printf("Status: %s\n", *account.Status)  // DISABLED

When to Disable

Maintenance - Temporarily pause trading during system maintenance
Risk Management - Quickly stop new orders during high volatility
Investigation - Pause trading while reviewing account activity

Disable vs Disconnect

Action	Effect	Reversible
Disable	Prevents new orders, keeps connection	Yes (Enable)
Disconnect	Removes account completely	No (must reconnect)

Disconnect Trading Account

Permanently disconnect a trading account from Cadenza:

Python
TypeScript
Go

response = trading_account_api.disconnect_trading_account(
    cadenza_client.DisconnectTradingAccountRequest(
        trading_account_id=trading_account_id
    )
)

print(f"Disconnected: {response.data.status}")  # DISCONNECTED

const response = await tradingAccountApi.disconnectTradingAccount({
  tradingAccountId: tradingAccountId,
})

console.log('Disconnected:', response.data.data.status)  // DISCONNECTED

response, _, err := apiClient.TradingAccountAPI.DisconnectTradingAccount(ctx).
    DisconnectTradingAccountRequest(client.DisconnectTradingAccountRequest{
        TradingAccountId: tradingAccountId,
    }).Execute()
if err != nil {
    panic(err)
}

fmt.Printf("Disconnected: %s\n", *response.Data.Status)  // DISCONNECTED

Disconnection Effects

Effect	Description
Status	Account status becomes `DISCONNECTED`
Orders	Open orders remain on exchange
Portfolio	No longer synced in Cadenza
WebSocket	Subscription channels closed
Credential	Remains active (can connect other accounts)

warning

Disconnection is permanent. To reconnect, you must call connectTradingAccount again.

Update Trading Account

Update the nickname of a trading account:

Python
TypeScript
Go

response = trading_account_api.update_trading_account(
    cadenza_client.UpdateTradingAccountRequest(
        trading_account_id=trading_account_id,
        nickname="New Nickname"
    )
)

account = response.data
print(f"Updated nickname: {account.nickname}")

const response = await tradingAccountApi.updateTradingAccount({
  tradingAccountId: tradingAccountId,
  nickname: 'New Nickname',
})

const account = response.data.data
console.log('Updated nickname:', account.nickname)

response, _, err := apiClient.TradingAccountAPI.UpdateTradingAccount(ctx).
    UpdateTradingAccountRequest(client.UpdateTradingAccountRequest{
        TradingAccountId: tradingAccountId,
        Nickname:         client.PtrString("New Nickname"),
    }).Execute()
if err != nil {
    panic(err)
}

account := response.Data
fmt.Printf("Updated nickname: %s\n", *account.Nickname)

Account Operations History

View the history of operations on a trading account:

Python
TypeScript
Go

response = trading_account_api.list_trading_account_operations(
    trading_account_id=trading_account_id
)

for operation in response.data:
    print(f"{operation.operation_type}: {operation.created_at}")

const response = await tradingAccountApi.listTradingAccountOperations(
  tradingAccountId
)

response.data.data.forEach(operation => {
  console.log(`${operation.operationType}: ${operation.createdAt}`)
})

response, _, err := apiClient.TradingAccountAPI.ListTradingAccountOperations(ctx).
    TradingAccountId(tradingAccountId).
    Execute()
if err != nil {
    panic(err)
}

for _, operation := range response.Data {
    fmt.Printf("%s: %v\n", *operation.OperationType, *operation.CreatedAt)
}

Error Handling

Error Code	Description
`400`	Invalid request parameters
`401`	Authentication required
`404`	Trading account not found
`409`	Cannot disable account with open orders
`422`	Invalid state transition

List Trading Accounts​

Filter by Venue​

Filter by Status​

Enable Trading Account​

Disable Trading Account​

When to Disable​

Disable vs Disconnect​

Disconnect Trading Account​

Disconnection Effects​

Update Trading Account​

Account Operations History​

Error Handling​

Related​