Verify a Credential

Verify your credential to confirm the API keys are valid and discover available trading accounts on the exchange.

Why Verify?

Verification serves two purposes:

1. Validate API Keys - Confirms your credentials can authenticate with the exchange
2. Discover Accounts - Returns a list of available trading account identifiers (e.g., spot, margin, futures)

Verify Credential

Python

response = credential_api.verify_trading_account_credential(
    cadenza_client.VerifyTradingAccountCredentialRequest(
        credential_id=credential_id
    )
)

result = response.data
print(f"Status: {result.status}")  # VERIFIED or FAILED

# Available trading account identifiers
for identity in result.identities:
    print(f"Available account: {identity}")

TypeScript

const response = await credentialApi.verifyTradingAccountCredential({
  credentialId: credentialId,
})

const result = response.data.data
console.log('Status:', result.status)  // VERIFIED or FAILED

// Available trading account identifiers
result.identities?.forEach(identity => {
  console.log('Available account:', identity)
})

Go

response, _, err := apiClient.TradingAccountCredentialAPI.VerifyTradingAccountCredential(ctx).
    VerifyTradingAccountCredentialRequest(client.VerifyTradingAccountCredentialRequest{
        CredentialId: credentialId,
    }).Execute()
if err != nil {
    panic(err)
}

result := response.Data
fmt.Printf("Status: %s\n", *result.Status)  // VERIFIED or FAILED

// Available trading account identifiers
for _, identity := range result.Identities {
    fmt.Printf("Available account: %s\n", identity)
}

Request Parameters

Parameter	Type	Required	Description
credentialId	UUID	Yes	The credential ID to verify

Response

The response includes the verification result and available accounts:

{
  "data": {
    "credentialId": "550e8400-e29b-41d4-a716-446655440000",
    "venue": "BINANCE",
    "status": "VERIFIED",
    "identities": [
      "spot",
      "margin",
      "futures"
    ]
  },
  "success": true,
  "errno": 0,
  "error": null
}

Understanding Identities

The identities array contains the external trading account IDs available on the exchange. These vary by venue:

Binance

Identity	Description
spot	Spot trading account
margin	Cross margin account
isolated_margin	Isolated margin accounts
futures	USDT-M Futures account
coin_futures	COIN-M Futures account

OKX

Identity	Description
trading	Unified trading account
funding	Funding account

Bybit

Identity	Description
unified	Unified Trading Account
contract	Derivatives account
spot	Spot account
fund	Funding account

Verification Outcomes

Success (VERIFIED)

Python

if result.status == cadenza_client.CredentialStatus.VERIFIED:
    print("Credential verified successfully!")
    print(f"Found {len(result.identities)} trading accounts")

TypeScript

if (result.status === 'VERIFIED') {
  console.log('Credential verified successfully!')
  console.log(`Found ${result.identities?.length} trading accounts`)
}

Go

if *result.Status == client.CREDENTIALSTATUS_VERIFIED {
    fmt.Println("Credential verified successfully!")
    fmt.Printf("Found %d trading accounts\n", len(result.Identities))
}

Failure (FAILED)

If verification fails, check:

1. API Key Validity - Ensure the key hasn't expired or been revoked
2. IP Whitelist - Add Cadenza's IP addresses to your exchange whitelist
3. Permissions - Ensure required permissions are enabled
4. Passphrase - For OKX, verify the passphrase is correct

Python

if result.status == cadenza_client.CredentialStatus.FAILED:
    print("Verification failed. Please check your API credentials.")

TypeScript

if (result.status === 'FAILED') {
  console.log('Verification failed. Please check your API credentials.')
}

Go

if *result.Status == client.CREDENTIALSTATUS_FAILED {
    fmt.Println("Verification failed. Please check your API credentials.")
}

Complete Example

Python

# Create and verify credential in one flow
create_response = credential_api.create_trading_account_credential(
    cadenza_client.CreateTradingAccountCredentialRequest(
        venue=cadenza_client.Venue.BINANCE,
        credential_type=cadenza_client.CredentialType.EXCHANGE,
        api_key="your-api-key",
        api_secret="your-api-secret",
        nickname="My Binance API"
    )
)
credential_id = create_response.data.credential_id

# Verify the credential
verify_response = credential_api.verify_trading_account_credential(
    cadenza_client.VerifyTradingAccountCredentialRequest(
        credential_id=credential_id
    )
)

result = verify_response.data
if result.status == cadenza_client.CredentialStatus.VERIFIED:
    print(f"Verified! Available accounts: {result.identities}")
    # Now you can connect a trading account
else:
    print("Verification failed")

TypeScript

// Create and verify credential in one flow
const createResponse = await credentialApi.createTradingAccountCredential({
  venue: 'BINANCE',
  credentialType: 'EXCHANGE',
  apiKey: 'your-api-key',
  apiSecret: 'your-api-secret',
  nickname: 'My Binance API',
})
const credentialId = createResponse.data.data.credentialId

// Verify the credential
const verifyResponse = await credentialApi.verifyTradingAccountCredential({
  credentialId: credentialId,
})

const result = verifyResponse.data.data
if (result.status === 'VERIFIED') {
  console.log('Verified! Available accounts:', result.identities)
  // Now you can connect a trading account
} else {
  console.log('Verification failed')
}

Go

// Create and verify credential in one flow
createResponse, _, err := apiClient.TradingAccountCredentialAPI.CreateTradingAccountCredential(ctx).
    CreateTradingAccountCredentialRequest(client.CreateTradingAccountCredentialRequest{
        Venue:          client.VENUE_BINANCE,
        CredentialType: client.CREDENTIALTYPE_EXCHANGE,
        ApiKey:         client.PtrString("your-api-key"),
        ApiSecret:      client.PtrString("your-api-secret"),
        Nickname:       client.PtrString("My Binance API"),
    }).Execute()
if err != nil {
    panic(err)
}
credentialId := *createResponse.Data.CredentialId

// Verify the credential
verifyResponse, _, err := apiClient.TradingAccountCredentialAPI.VerifyTradingAccountCredential(ctx).
    VerifyTradingAccountCredentialRequest(client.VerifyTradingAccountCredentialRequest{
        CredentialId: credentialId,
    }).Execute()
if err != nil {
    panic(err)
}

result := verifyResponse.Data
if *result.Status == client.CREDENTIALSTATUS_VERIFIED {
    fmt.Printf("Verified! Available accounts: %v\n", result.Identities)
    // Now you can connect a trading account
} else {
    fmt.Println("Verification failed")
}

Next Steps

After verifying your credential, you can:

• Connect a Trading Account using the credential
• Manage Credentials - List, rotate, or revoke