COINBOX API Reference

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query conversions($search: String, $pager: PagerInput, $dateRange: DateRangeInput, $wallet_id: String!) { conversions(search: $search, pager: $pager, dateRange: $dateRange, wallet_id: $wallet_id) { conversion_id conversion_quote_id reference source_currency_id source_currency_amount target_currency_id target_currency_amount instrument_id fee_currency_id fee_currency_amount price status message error_message created_at_iso updated_at_iso wallet_id instrument { name base_currency_id quantity_decimals quote_quantity_decimals } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query conversions($search: String, $pager: PagerInput, $dateRange: DateRangeInput, $wallet_id: String!) { conversions(search: $search, pager: $pager, dateRange: $dateRange, wallet_id: $wallet_id) { conversion_id conversion_quote_id reference source_currency_id source_currency_amount target_currency_id target_currency_amount instrument_id fee_currency_id fee_currency_amount price status message error_message created_at_iso updated_at_iso wallet_id instrument { name base_currency_id quantity_decimals quote_quantity_decimals } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query conversions($search: String, $pager: PagerInput, $dateRange: DateRangeInput, $wallet_id: String!) { conversions(search: $search, pager: $pager, dateRange: $dateRange, wallet_id: $wallet_id) { conversion_id conversion_quote_id reference source_currency_id source_currency_amount target_currency_id target_currency_amount instrument_id fee_currency_id fee_currency_amount price status message error_message created_at_iso updated_at_iso wallet_id instrument { name base_currency_id quantity_decimals quote_quantity_decimals } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_conversion_order($conversion_quote_id: String!, $wallet_id: String!) { create_conversion_order(conversion_quote_id: $conversion_quote_id, wallet_id: $wallet_id) { status message created_at updated_at error_message price fee_currency_id fee_currency_amount conversion_quote_id source_currency_id target_currency_id target_currency_amount source_currency_amount } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_conversion_order($conversion_quote_id: String!, $wallet_id: String!) { create_conversion_order(conversion_quote_id: $conversion_quote_id, wallet_id: $wallet_id) { status message created_at updated_at error_message price fee_currency_id fee_currency_amount conversion_quote_id source_currency_id target_currency_id target_currency_amount source_currency_amount } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_conversion_order($conversion_quote_id: String!, $wallet_id: String!) { create_conversion_order(conversion_quote_id: $conversion_quote_id, wallet_id: $wallet_id) { status message created_at updated_at error_message price fee_currency_id fee_currency_amount conversion_quote_id source_currency_id target_currency_id target_currency_amount source_currency_amount } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_conversion_quote($source_currency_id: String!, $target_currency_id: String!, $target_currency_amount: Float, $source_currency_amount: Float, $ttl: Int, $dry_run: ToggleSwitch, $instrument_id: String) { create_conversion_quote(source_currency_id: $source_currency_id, target_currency_id: $target_currency_id, target_currency_amount: $target_currency_amount, source_currency_amount: $source_currency_amount, ttl: $ttl, dry_run: $dry_run, instrument_id: $instrument_id) { expires_at expires_at_iso current_time_iso fees { currency_id amount } price fee_currency_id fee_currency_amount conversion_quote_id source_currency_id target_currency_id target_currency_amount source_currency_amount } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_conversion_quote($source_currency_id: String!, $target_currency_id: String!, $target_currency_amount: Float, $source_currency_amount: Float, $ttl: Int, $dry_run: ToggleSwitch, $instrument_id: String) { create_conversion_quote(source_currency_id: $source_currency_id, target_currency_id: $target_currency_id, target_currency_amount: $target_currency_amount, source_currency_amount: $source_currency_amount, ttl: $ttl, dry_run: $dry_run, instrument_id: $instrument_id) { expires_at expires_at_iso current_time_iso fees { currency_id amount } price fee_currency_id fee_currency_amount conversion_quote_id source_currency_id target_currency_id target_currency_amount source_currency_amount } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_conversion_quote($source_currency_id: String!, $target_currency_id: String!, $target_currency_amount: Float, $source_currency_amount: Float, $ttl: Int, $dry_run: ToggleSwitch, $instrument_id: String) { create_conversion_quote(source_currency_id: $source_currency_id, target_currency_id: $target_currency_id, target_currency_amount: $target_currency_amount, source_currency_amount: $source_currency_amount, ttl: $ttl, dry_run: $dry_run, instrument_id: $instrument_id) { expires_at expires_at_iso current_time_iso fees { currency_id amount } price fee_currency_id fee_currency_amount conversion_quote_id source_currency_id target_currency_id target_currency_amount source_currency_amount } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query currencies($limit: Int!, $store_mode: ToggleSwitch) { currencies(limit: $limit, store_mode: $store_mode) { currency_id name precision type is_active } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query currencies($limit: Int!, $store_mode: ToggleSwitch) { currencies(limit: $limit, store_mode: $store_mode) { currency_id name precision type is_active } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query currencies($limit: Int!, $store_mode: ToggleSwitch) { currencies(limit: $limit, store_mode: $store_mode) { currency_id name precision type is_active } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query currency_prices($base_currencies: [String!]!, $quote_currency: String!) { currency_prices(base_currencies: $base_currencies, quote_currency: $quote_currency) { base_currency_id quote_currency_id ask bid source updated_at } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query currency_prices($base_currencies: [String!]!, $quote_currency: String!) { currency_prices(base_currencies: $base_currencies, quote_currency: $quote_currency) { base_currency_id quote_currency_id ask bid source updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query currency_prices($base_currencies: [String!]!, $quote_currency: String!) { currency_prices(base_currencies: $base_currencies, quote_currency: $quote_currency) { base_currency_id quote_currency_id ask bid source updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"subscription currency_prices($base_currencies: [String!]!, $quote_currency: String!) { currency_prices(base_currencies: $base_currencies, quote_currency: $quote_currency) { base_currency_id quote_currency_id ask bid source updated_at } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """subscription currency_prices($base_currencies: [String!]!, $quote_currency: String!) { currency_prices(base_currencies: $base_currencies, quote_currency: $quote_currency) { base_currency_id quote_currency_id ask bid source updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `subscription currency_prices($base_currencies: [String!]!, $quote_currency: String!) { currency_prices(base_currencies: $base_currencies, quote_currency: $quote_currency) { base_currency_id quote_currency_id ask bid source updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_withdrawal_crypto($crypto_address: String!, $amount: Float!, $crypto_address_tag_type: CryptoAddressTagType, $crypto_network_fee_preference: CryptoNetworkFeePreference, $crypto_address_tag_value: String, $mfa_token: String, $payment_route_id: String!, $fees_included: ToggleSwitch, $comment: String, $travel_rule_properties: TravelRulePropertiesArgs, $vasp_id: String, $wallet_id: String) { create_withdrawal_crypto(crypto_address: $crypto_address, amount: $amount, crypto_address_tag_type: $crypto_address_tag_type, crypto_network_fee_preference: $crypto_network_fee_preference, crypto_address_tag_value: $crypto_address_tag_value, mfa_token: $mfa_token, payment_route_id: $payment_route_id, fees_included: $fees_included, comment: $comment, travel_rule_properties: $travel_rule_properties, vasp_id: $vasp_id, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_withdrawal_crypto($crypto_address: String!, $amount: Float!, $crypto_address_tag_type: CryptoAddressTagType, $crypto_network_fee_preference: CryptoNetworkFeePreference, $crypto_address_tag_value: String, $mfa_token: String, $payment_route_id: String!, $fees_included: ToggleSwitch, $comment: String, $travel_rule_properties: TravelRulePropertiesArgs, $vasp_id: String, $wallet_id: String) { create_withdrawal_crypto(crypto_address: $crypto_address, amount: $amount, crypto_address_tag_type: $crypto_address_tag_type, crypto_network_fee_preference: $crypto_network_fee_preference, crypto_address_tag_value: $crypto_address_tag_value, mfa_token: $mfa_token, payment_route_id: $payment_route_id, fees_included: $fees_included, comment: $comment, travel_rule_properties: $travel_rule_properties, vasp_id: $vasp_id, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_withdrawal_crypto($crypto_address: String!, $amount: Float!, $crypto_address_tag_type: CryptoAddressTagType, $crypto_network_fee_preference: CryptoNetworkFeePreference, $crypto_address_tag_value: String, $mfa_token: String, $payment_route_id: String!, $fees_included: ToggleSwitch, $comment: String, $travel_rule_properties: TravelRulePropertiesArgs, $vasp_id: String, $wallet_id: String) { create_withdrawal_crypto(crypto_address: $crypto_address, amount: $amount, crypto_address_tag_type: $crypto_address_tag_type, crypto_network_fee_preference: $crypto_network_fee_preference, crypto_address_tag_value: $crypto_address_tag_value, mfa_token: $mfa_token, payment_route_id: $payment_route_id, fees_included: $fees_included, comment: $comment, travel_rule_properties: $travel_rule_properties, vasp_id: $vasp_id, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_withdrawal_fiat($amount: Float!, $mfa_token: String, $properties: [FiatDepositPropertyInput!]!, $payment_route_id: String!, $wallet_id: String) { create_withdrawal_fiat(amount: $amount, mfa_token: $mfa_token, properties: $properties, payment_route_id: $payment_route_id, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_withdrawal_fiat($amount: Float!, $mfa_token: String, $properties: [FiatDepositPropertyInput!]!, $payment_route_id: String!, $wallet_id: String) { create_withdrawal_fiat(amount: $amount, mfa_token: $mfa_token, properties: $properties, payment_route_id: $payment_route_id, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_withdrawal_fiat($amount: Float!, $mfa_token: String, $properties: [FiatDepositPropertyInput!]!, $payment_route_id: String!, $wallet_id: String) { create_withdrawal_fiat(amount: $amount, mfa_token: $mfa_token, properties: $properties, payment_route_id: $payment_route_id, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query deposit_address_crypto($currency_id: String!, $reference: String, $payment_route_id: String!) { deposit_address_crypto(currency_id: $currency_id, reference: $reference, payment_route_id: $payment_route_id) { deposit_address_crypto_id currency_id address address_tag_type address_tag_value network created_at updated_at } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query deposit_address_crypto($currency_id: String!, $reference: String, $payment_route_id: String!) { deposit_address_crypto(currency_id: $currency_id, reference: $reference, payment_route_id: $payment_route_id) { deposit_address_crypto_id currency_id address address_tag_type address_tag_value network created_at updated_at } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query deposit_address_crypto($currency_id: String!, $reference: String, $payment_route_id: String!) { deposit_address_crypto(currency_id: $currency_id, reference: $reference, payment_route_id: $payment_route_id) { deposit_address_crypto_id currency_id address address_tag_type address_tag_value network created_at updated_at } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query payments_routes($payment_route_id: String!) { payments_routes(payment_route_id: $payment_route_id) { fiat_deposit_properties { name value } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query payments_routes($payment_route_id: String!) { payments_routes(payment_route_id: $payment_route_id) { fiat_deposit_properties { name value } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query payments_routes($payment_route_id: String!) { payments_routes(payment_route_id: $payment_route_id) { fiat_deposit_properties { name value } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"subscription instrument_price($instrument_id: String) { instrument_price(instrument_id: $instrument_id) { instrument_id ask bid price_24h_change ts_iso } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """subscription instrument_price($instrument_id: String) { instrument_price(instrument_id: $instrument_id) { instrument_id ask bid price_24h_change ts_iso } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `subscription instrument_price($instrument_id: String) { instrument_price(instrument_id: $instrument_id) { instrument_id ask bid price_24h_change ts_iso } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"subscription instrument_price_bar($instrument_id: String!, $periodicity: InstrumentHistoryPeriodicity!) { instrument_price_bar(instrument_id: $instrument_id, periodicity: $periodicity) { instrument_id high low ts_iso close open } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """subscription instrument_price_bar($instrument_id: String!, $periodicity: InstrumentHistoryPeriodicity!) { instrument_price_bar(instrument_id: $instrument_id, periodicity: $periodicity) { instrument_id high low ts_iso close open } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `subscription instrument_price_bar($instrument_id: String!, $periodicity: InstrumentHistoryPeriodicity!) { instrument_price_bar(instrument_id: $instrument_id, periodicity: $periodicity) { instrument_id high low ts_iso close open } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query instrument_price_bars($instrument_id: String!, $limit: String, $date_range: DateRangeInput, $periodicity: InstrumentHistoryPeriodicity) { instrument_price_bars(instrument_id: $instrument_id, limit: $limit, date_range: $date_range, periodicity: $periodicity) { instrument_id high low ts_iso close open } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query instrument_price_bars($instrument_id: String!, $limit: String, $date_range: DateRangeInput, $periodicity: InstrumentHistoryPeriodicity) { instrument_price_bars(instrument_id: $instrument_id, limit: $limit, date_range: $date_range, periodicity: $periodicity) { instrument_id high low ts_iso close open } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query instrument_price_bars($instrument_id: String!, $limit: String, $date_range: DateRangeInput, $periodicity: InstrumentHistoryPeriodicity) { instrument_price_bars(instrument_id: $instrument_id, limit: $limit, date_range: $date_range, periodicity: $periodicity) { instrument_id high low ts_iso close open } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query instruments($is_active: ToggleSwitch, $instrument_id: String, $search: String, $page: Int, $limit: Int, $sort: SortInput) { instruments(is_active: $is_active, instrument_id: $instrument_id, search: $search, page: $page, limit: $limit, sort: $sort) { instrument_id price_bars { instrument_id high low ts_iso close open } name base_currency_id quote_currency_id quote_quantity_decimals quantity_decimals price_decimals min_quantity max_quantity min_quote_quantity max_quote_quantity is_active meta max_conversion_quote_ttl price { instrument_id ask bid price_24h_change ts_iso } recent_price_bar { high low } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query instruments($is_active: ToggleSwitch, $instrument_id: String, $search: String, $page: Int, $limit: Int, $sort: SortInput) { instruments(is_active: $is_active, instrument_id: $instrument_id, search: $search, page: $page, limit: $limit, sort: $sort) { instrument_id price_bars { instrument_id high low ts_iso close open } name base_currency_id quote_currency_id quote_quantity_decimals quantity_decimals price_decimals min_quantity max_quantity min_quote_quantity max_quote_quantity is_active meta max_conversion_quote_ttl price { instrument_id ask bid price_24h_change ts_iso } recent_price_bar { high low } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query instruments($is_active: ToggleSwitch, $instrument_id: String, $search: String, $page: Int, $limit: Int, $sort: SortInput) { instruments(is_active: $is_active, instrument_id: $instrument_id, search: $search, page: $page, limit: $limit, sort: $sort) { instrument_id price_bars { instrument_id high low ts_iso close open } name base_currency_id quote_currency_id quote_quantity_decimals quantity_decimals price_decimals min_quantity max_quantity min_quote_quantity max_quote_quantity is_active meta max_conversion_quote_ttl price { instrument_id ask bid price_24h_change ts_iso } recent_price_bar { high low } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"subscription all_orders($instruments: [String!]) { all_orders(instruments: $instruments) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """subscription all_orders($instruments: [String!]) { all_orders(instruments: $instruments) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `subscription all_orders($instruments: [String!]) { all_orders(instruments: $instruments) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation cancel_all_orders { cancel_all_orders }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation cancel_all_orders { cancel_all_orders }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation cancel_all_orders { cancel_all_orders }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation cancel_order($order_id: String!) { cancel_order(order_id: $order_id) }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation cancel_order($order_id: String!) { cancel_order(order_id: $order_id) }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation cancel_order($order_id: String!) { cancel_order(order_id: $order_id) }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query closed_orders($instrument_id: String, $status: [OrderStatus!], $side: OrderSide, $pager: PagerInput, $dateRange: DateRangeInput, $parent_order_id: String, $wallet_id: String!) { closed_orders(instrument_id: $instrument_id, status: $status, side: $side, pager: $pager, dateRange: $dateRange, parent_order_id: $parent_order_id, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } total } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query closed_orders($instrument_id: String, $status: [OrderStatus!], $side: OrderSide, $pager: PagerInput, $dateRange: DateRangeInput, $parent_order_id: String, $wallet_id: String!) { closed_orders(instrument_id: $instrument_id, status: $status, side: $side, pager: $pager, dateRange: $dateRange, parent_order_id: $parent_order_id, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } total } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query closed_orders($instrument_id: String, $status: [OrderStatus!], $side: OrderSide, $pager: PagerInput, $dateRange: DateRangeInput, $parent_order_id: String, $wallet_id: String!) { closed_orders(instrument_id: $instrument_id, status: $status, side: $side, pager: $pager, dateRange: $dateRange, parent_order_id: $parent_order_id, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } total } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_order($instrument_id: String!, $type: OrderType!, $price: Float, $stop_price: Float, $side: OrderSide!, $time_in_force: OrderTimeInForce!, $quantity: Float!, $expires_at: String, $quantity_mode: OrderQuantityMode, $post_only: ToggleSwitch, $wallet_id: String!) { create_order(instrument_id: $instrument_id, type: $type, price: $price, stop_price: $stop_price, side: $side, time_in_force: $time_in_force, quantity: $quantity, expires_at: $expires_at, quantity_mode: $quantity_mode, post_only: $post_only, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_order($instrument_id: String!, $type: OrderType!, $price: Float, $stop_price: Float, $side: OrderSide!, $time_in_force: OrderTimeInForce!, $quantity: Float!, $expires_at: String, $quantity_mode: OrderQuantityMode, $post_only: ToggleSwitch, $wallet_id: String!) { create_order(instrument_id: $instrument_id, type: $type, price: $price, stop_price: $stop_price, side: $side, time_in_force: $time_in_force, quantity: $quantity, expires_at: $expires_at, quantity_mode: $quantity_mode, post_only: $post_only, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_order($instrument_id: String!, $type: OrderType!, $price: Float, $stop_price: Float, $side: OrderSide!, $time_in_force: OrderTimeInForce!, $quantity: Float!, $expires_at: String, $quantity_mode: OrderQuantityMode, $post_only: ToggleSwitch, $wallet_id: String!) { create_order(instrument_id: $instrument_id, type: $type, price: $price, stop_price: $stop_price, side: $side, time_in_force: $time_in_force, quantity: $quantity, expires_at: $expires_at, quantity_mode: $quantity_mode, post_only: $post_only, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query estimate_order($source_currency_id: String!, $target_currency_id: String!, $price: Float, $target_currency_amount: Float, $source_currency_amount: Float, $instrument_id: String) { estimate_order(source_currency_id: $source_currency_id, target_currency_id: $target_currency_id, price: $price, target_currency_amount: $target_currency_amount, source_currency_amount: $source_currency_amount, instrument_id: $instrument_id) { type price quantity side quantity_mode instrument { instrument_id } fees { currency_id amount type } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query estimate_order($source_currency_id: String!, $target_currency_id: String!, $price: Float, $target_currency_amount: Float, $source_currency_amount: Float, $instrument_id: String) { estimate_order(source_currency_id: $source_currency_id, target_currency_id: $target_currency_id, price: $price, target_currency_amount: $target_currency_amount, source_currency_amount: $source_currency_amount, instrument_id: $instrument_id) { type price quantity side quantity_mode instrument { instrument_id } fees { currency_id amount type } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query estimate_order($source_currency_id: String!, $target_currency_id: String!, $price: Float, $target_currency_amount: Float, $source_currency_amount: Float, $instrument_id: String) { estimate_order(source_currency_id: $source_currency_id, target_currency_id: $target_currency_id, price: $price, target_currency_amount: $target_currency_amount, source_currency_amount: $source_currency_amount, instrument_id: $instrument_id) { type price quantity side quantity_mode instrument { instrument_id } fees { currency_id amount type } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query open_orders($instrument_id: String, $status: [OrderStatus!], $side: OrderSide, $pager: PagerInput, $dateRange: DateRangeInput, $parent_order_id: String, $wallet_id: String!) { open_orders(instrument_id: $instrument_id, status: $status, side: $side, pager: $pager, dateRange: $dateRange, parent_order_id: $parent_order_id, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } created_at_iso updated_at_iso } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query open_orders($instrument_id: String, $status: [OrderStatus!], $side: OrderSide, $pager: PagerInput, $dateRange: DateRangeInput, $parent_order_id: String, $wallet_id: String!) { open_orders(instrument_id: $instrument_id, status: $status, side: $side, pager: $pager, dateRange: $dateRange, parent_order_id: $parent_order_id, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } created_at_iso updated_at_iso } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query open_orders($instrument_id: String, $status: [OrderStatus!], $side: OrderSide, $pager: PagerInput, $dateRange: DateRangeInput, $parent_order_id: String, $wallet_id: String!) { open_orders(instrument_id: $instrument_id, status: $status, side: $side, pager: $pager, dateRange: $dateRange, parent_order_id: $parent_order_id, wallet_id: $wallet_id) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } created_at_iso updated_at_iso } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"subscription orderbook($instrument_id: String!) { orderbook(instrument_id: $instrument_id) { instrument_id buy { quantity price } sell { quantity price } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """subscription orderbook($instrument_id: String!) { orderbook(instrument_id: $instrument_id) { instrument_id buy { quantity price } sell { quantity price } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `subscription orderbook($instrument_id: String!) { orderbook(instrument_id: $instrument_id) { instrument_id buy { quantity price } sell { quantity price } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation update_open_order($order_id: String!, $quantity: Float!, $price: Float!, $expires_at: String) { update_open_order(order_id: $order_id, quantity: $quantity, price: $price, expires_at: $expires_at) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation update_open_order($order_id: String!, $quantity: Float!, $price: Float!, $expires_at: String) { update_open_order(order_id: $order_id, quantity: $quantity, price: $price, expires_at: $expires_at) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation update_open_order($order_id: String!, $quantity: Float!, $price: Float!, $expires_at: String) { update_open_order(order_id: $order_id, quantity: $quantity, price: $price, expires_at: $expires_at) { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation create_payment_session($payment_route_id: String!, $payment_type: PaymentType!) { create_payment_session(payment_route_id: $payment_route_id, payment_type: $payment_type) }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation create_payment_session($payment_route_id: String!, $payment_type: PaymentType!) { create_payment_session(payment_route_id: $payment_route_id, payment_type: $payment_type) }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation create_payment_session($payment_route_id: String!, $payment_type: PaymentType!) { create_payment_session(payment_route_id: $payment_route_id, payment_type: $payment_type) }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"mutation estimate_payment_fee($user_id: String, $payment_route_id: String!, $type: PaymentType!, $amount: Float!, $crypto_network_fee_preference: CryptoNetworkFeePreference) { estimate_payment_fee(user_id: $user_id, payment_route_id: $payment_route_id, type: $type, amount: $amount, crypto_network_fee_preference: $crypto_network_fee_preference) }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """mutation estimate_payment_fee($user_id: String, $payment_route_id: String!, $type: PaymentType!, $amount: Float!, $crypto_network_fee_preference: CryptoNetworkFeePreference) { estimate_payment_fee(user_id: $user_id, payment_route_id: $payment_route_id, type: $type, amount: $amount, crypto_network_fee_preference: $crypto_network_fee_preference) }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `mutation estimate_payment_fee($user_id: String, $payment_route_id: String!, $type: PaymentType!, $amount: Float!, $crypto_network_fee_preference: CryptoNetworkFeePreference) { estimate_payment_fee(user_id: $user_id, payment_route_id: $payment_route_id, type: $type, amount: $amount, crypto_network_fee_preference: $crypto_network_fee_preference) }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query payments($type: PaymentType, $currency_id: String, $dateRange: DateRangeInput, $pager: PagerInput, $approval_status: [PaymentApprovalStatus!], $status: [PaymentStatus!], $wallet_id: String) { payments(type: $type, currency_id: $currency_id, dateRange: $dateRange, pager: $pager, approval_status: $approval_status, status: $status, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } amount_quoted fee_quoted } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query payments($type: PaymentType, $currency_id: String, $dateRange: DateRangeInput, $pager: PagerInput, $approval_status: [PaymentApprovalStatus!], $status: [PaymentStatus!], $wallet_id: String) { payments(type: $type, currency_id: $currency_id, dateRange: $dateRange, pager: $pager, approval_status: $approval_status, status: $status, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } amount_quoted fee_quoted } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query payments($type: PaymentType, $currency_id: String, $dateRange: DateRangeInput, $pager: PagerInput, $approval_status: [PaymentApprovalStatus!], $status: [PaymentStatus!], $wallet_id: String) { payments(type: $type, currency_id: $currency_id, dateRange: $dateRange, pager: $pager, approval_status: $approval_status, status: $status, wallet_id: $wallet_id) { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } amount_quoted fee_quoted } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query account_transactions($currency_id: String, $pager: PagerInput, $dateRange: DateRangeInput, $wallet_id: String!, $type: AccountTransactionType) { account_transactions(currency_id: $currency_id, pager: $pager, dateRange: $dateRange, wallet_id: $wallet_id, type: $type) { account_transaction_id serial_id parent_transaction_id client_transaction_id user_id account_id payment_id currency_id transaction_class type order_id trade_id conversion_id amount post_balance comment created_at created_at_iso created_by wallet_id payment { manual_transaction_date_iso } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query account_transactions($currency_id: String, $pager: PagerInput, $dateRange: DateRangeInput, $wallet_id: String!, $type: AccountTransactionType) { account_transactions(currency_id: $currency_id, pager: $pager, dateRange: $dateRange, wallet_id: $wallet_id, type: $type) { account_transaction_id serial_id parent_transaction_id client_transaction_id user_id account_id payment_id currency_id transaction_class type order_id trade_id conversion_id amount post_balance comment created_at created_at_iso created_by wallet_id payment { manual_transaction_date_iso } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query account_transactions($currency_id: String, $pager: PagerInput, $dateRange: DateRangeInput, $wallet_id: String!, $type: AccountTransactionType) { account_transactions(currency_id: $currency_id, pager: $pager, dateRange: $dateRange, wallet_id: $wallet_id, type: $type) { account_transaction_id serial_id parent_transaction_id client_transaction_id user_id account_id payment_id currency_id transaction_class type order_id trade_id conversion_id amount post_balance comment created_at created_at_iso created_by wallet_id payment { manual_transaction_date_iso } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query accounts_balances($wallet_id: String) { accounts_balances(wallet_id: $wallet_id) { currency_id total_balance exposed_balance margin_exposure free_balance } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query accounts_balances($wallet_id: String) { accounts_balances(wallet_id: $wallet_id) { currency_id total_balance exposed_balance margin_exposure free_balance } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query accounts_balances($wallet_id: String) { accounts_balances(wallet_id: $wallet_id) { currency_id total_balance exposed_balance margin_exposure free_balance } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query portfolio_history($currency_id: String!, $timestamp: String!, $interval: PortfolioHistoryInterval!) { portfolio_history(currency_id: $currency_id, timestamp: $timestamp, interval: $interval) }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query portfolio_history($currency_id: String!, $timestamp: String!, $interval: PortfolioHistoryInterval!) { portfolio_history(currency_id: $currency_id, timestamp: $timestamp, interval: $interval) }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query portfolio_history($currency_id: String!, $timestamp: String!, $interval: PortfolioHistoryInterval!) { portfolio_history(currency_id: $currency_id, timestamp: $timestamp, interval: $interval) }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"subscription user_update { user_update { order { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } account_transaction { currency_id type amount post_balance order_id } payment { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } account { account_id balance } notification { title body class code vars } healthcheck { maintenance_message maintenance_mode } conversion { conversion_id conversion_quote_id reference source_currency_id source_currency_amount target_currency_id target_currency_amount instrument_id fee_currency_id fee_currency_amount price status message error_message created_at_iso updated_at_iso wallet_id instrument { name base_currency_id quantity_decimals quote_quantity_decimals } } } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """subscription user_update { user_update { order { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } account_transaction { currency_id type amount post_balance order_id } payment { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } account { account_id balance } notification { title body class code vars } healthcheck { maintenance_message maintenance_mode } conversion { conversion_id conversion_quote_id reference source_currency_id source_currency_amount target_currency_id target_currency_amount instrument_id fee_currency_id fee_currency_amount price status message error_message created_at_iso updated_at_iso wallet_id instrument { name base_currency_id quantity_decimals quote_quantity_decimals } } } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `subscription user_update { user_update { order { order_id type side status price stop_price quantity executed_quantity remaining_quantity quantity_mode instrument_id message updated_at created_at expires_at expires_at_iso time_in_force vwap wallet_id instrument { quote_currency_id name base_currency_id quantity_decimals quote_quantity_decimals price_decimals } fees { currency_id amount type } } account_transaction { currency_id type amount post_balance order_id } payment { payment_id currency_id amount type crypto_transaction_id crypto_address crypto_address_tag_type crypto_address_tag_value crypto_network approval_status psp_service_id reference fee_amount status message error_message comment created_at updated_at manual_transaction_date_iso fees_included wallet_id payment_route { name payment_route_id } account_transactions { currency_id transaction_class post_balance amount } properties { name value } } account { account_id balance } notification { title body class code vars } healthcheck { maintenance_message maintenance_mode } conversion { conversion_id conversion_quote_id reference source_currency_id source_currency_amount target_currency_id target_currency_amount instrument_id fee_currency_id fee_currency_amount price status message error_message created_at_iso updated_at_iso wallet_id instrument { name base_currency_id quantity_decimals quote_quantity_decimals } } } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);

curl -X POST 'https://vakotrade-coinbox.cryptosrvc.com/graphql' \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"query trading_fees($instrument_id: String, $fee_group_id: String, $pager: PagerInput) { trading_fees(instrument_id: $instrument_id, fee_group_id: $fee_group_id, pager: $pager) { instrument_id maker_flat maker_progressive taker_flat taker_progressive } }","variables":{}}'

import requests

url = "https://vakotrade-coinbox.cryptosrvc.com/graphql"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
    "query": """query trading_fees($instrument_id: String, $fee_group_id: String, $pager: PagerInput) { trading_fees(instrument_id: $instrument_id, fee_group_id: $fee_group_id, pager: $pager) { instrument_id maker_flat maker_progressive taker_flat taker_progressive } }""",
    "variables": {},
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())

const response = await fetch("https://vakotrade-coinbox.cryptosrvc.com/graphql", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${YOUR_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    query: `query trading_fees($instrument_id: String, $fee_group_id: String, $pager: PagerInput) { trading_fees(instrument_id: $instrument_id, fee_group_id: $fee_group_id, pager: $pager) { instrument_id maker_flat maker_progressive taker_flat taker_progressive } }`,
    variables: {},
  }),
});
const data = await response.json();
console.log(data);