Uma API financeira pronta para a sua próxima grande integração.

const response = await fetch("https://sandbox-api.example.invalid/health/live", {
  method: 'GET',
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/health/live');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/health/live",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/health/ready", {
  method: 'GET',
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/health/ready');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/health/ready",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cashin", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": 25.9
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cashin');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "amount": 25.9
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "amount": 25.9
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/cashin",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cashout", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": 20,
    "pix_key": "<chave-pix-destino>",
    "pix_key_type": "random",
    "description": "Repasse"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cashout');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "amount": 20,
    "pix_key": "<chave-pix-destino>",
    "pix_key_type": "random",
    "description": "Repasse"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "amount": 20,
    "pix_key": "<chave-pix-destino>",
    "pix_key_type": "random",
    "description": "Repasse"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/cashout",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/pix/qr/decode", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "payload": "00020101021226810014br.gov.bcb.pix2559https://example.invalid/pix/cobranca-exemplo520400005303986540539.905802BR5905VEXUS6009SAO PAULO62070503***6304B9CE"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/pix/qr/decode');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "payload": "00020101021226810014br.gov.bcb.pix2559https://example.invalid/pix/cobranca-exemplo520400005303986540539.905802BR5905VEXUS6009SAO PAULO62070503***6304B9CE"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "payload": "00020101021226810014br.gov.bcb.pix2559https://example.invalid/pix/cobranca-exemplo520400005303986540539.905802BR5905VEXUS6009SAO PAULO62070503***6304B9CE"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/pix/qr/decode",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/pix/qr/pay", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "payload": "00020101021226810014br.gov.bcb.pix2559https://example.invalid/pix/cobranca-exemplo520400005303986540539.905802BR5905VEXUS6009SAO PAULO62070503***6304B9CE",
    "description": "Fornecedor"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/pix/qr/pay');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "payload": "00020101021226810014br.gov.bcb.pix2559https://example.invalid/pix/cobranca-exemplo520400005303986540539.905802BR5905VEXUS6009SAO PAULO62070503***6304B9CE",
    "description": "Fornecedor"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "payload": "00020101021226810014br.gov.bcb.pix2559https://example.invalid/pix/cobranca-exemplo520400005303986540539.905802BR5905VEXUS6009SAO PAULO62070503***6304B9CE",
    "description": "Fornecedor"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/pix/qr/pay",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/boleto/issue", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": 99.9,
    "due_date": "2026-09-30",
    "description": "Cobrança por boleto"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/boleto/issue');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "amount": 99.9,
    "due_date": "2026-09-30",
    "description": "Cobrança por boleto"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "amount": 99.9,
    "due_date": "2026-09-30",
    "description": "Cobrança por boleto"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/boleto/issue",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/boleto/info", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "billetCode": "00190000000000014990000000000000000000000000"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/boleto/info');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "billetCode": "00190000000000014990000000000000000000000000"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "billetCode": "00190000000000014990000000000000000000000000"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/boleto/info",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/boleto/pay", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "billetCode": "00190000000000014990000000000000000000000000"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/boleto/pay');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "billetCode": "00190000000000014990000000000000000000000000"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "billetCode": "00190000000000014990000000000000000000000000"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/boleto/pay",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/card/config", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/card/config');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/card/config",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/card/pay", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": 99.9,
    "external_id": "pedido-zoe-123",
    "buyer_name": "Cliente de Exemplo",
    "buyer_email": "cliente@example.com",
    "buyer_cpf": "52998224725",
    "card_token": "SUBSTITUA_PELO_TOKEN_DE_USO_UNICO",
    "payment_method_id": "visa",
    "installments": 1,
    "description": "Pedido ZoePay 123"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/card/pay');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "amount": 99.9,
    "external_id": "pedido-zoe-123",
    "buyer_name": "Cliente de Exemplo",
    "buyer_email": "cliente@example.com",
    "buyer_cpf": "52998224725",
    "card_token": "SUBSTITUA_PELO_TOKEN_DE_USO_UNICO",
    "payment_method_id": "visa",
    "installments": 1,
    "description": "Pedido ZoePay 123"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "amount": 99.9,
    "external_id": "pedido-zoe-123",
    "buyer_name": "Cliente de Exemplo",
    "buyer_email": "cliente@example.com",
    "buyer_cpf": "52998224725",
    "card_token": "SUBSTITUA_PELO_TOKEN_DE_USO_UNICO",
    "payment_method_id": "visa",
    "installments": 1,
    "description": "Pedido ZoePay 123"
}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/card/pay",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/methods", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/methods');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/checkout/methods",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/report", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/report');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/checkout/report",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/products", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/products');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/checkout/products",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/products", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "name": "Plano mensal",
    "price": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/products');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "name": "Plano mensal",
    "price": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "name": "Plano mensal",
    "price": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/checkout/products",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID", {
  method: 'PUT',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "name": "Plano mensal atualizado",
    "price": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "name": "Plano mensal atualizado",
    "price": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "name": "Plano mensal atualizado",
    "price": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}
''')
response = requests.request(
    'PUT',
    "https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID", {
  method: 'DELETE',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
response = requests.request(
    'DELETE',
    "https://sandbox-api.example.invalid/api/v1/checkout/products/SUBSTITUA_PELO_PRODUCT_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/links", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/links');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/checkout/links",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/links", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "title": "Pagamento de serviço",
    "amount": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/links');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "title": "Pagamento de serviço",
    "amount": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "title": "Pagamento de serviço",
    "amount": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/checkout/links",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID", {
  method: 'PUT',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "title": "Pagamento de serviço atualizado",
    "amount": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "title": "Pagamento de serviço atualizado",
    "amount": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "title": "Pagamento de serviço atualizado",
    "amount": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}
''')
response = requests.request(
    'PUT',
    "https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID/archive", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID/archive');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID/archive",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID/cancel", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "reason": "Solicitação de cancelamento do cliente"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID/cancel');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "reason": "Solicitação de cancelamento do cliente"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "reason": "Solicitação de cancelamento do cliente"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/checkout/links/SUBSTITUA_PELO_LINK_ID/cancel",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/networks", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/networks');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/networks",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/assets", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/assets');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/assets",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/swap-pairs", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/swap-pairs');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/swap-pairs",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/wallets", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/wallets');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/wallets",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/wallets", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "network": "BSC"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/wallets');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "network": "BSC"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "network": "BSC"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/wallets",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID/balances", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID/balances');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID/balances",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID/transactions", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID/transactions');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/wallets/SUBSTITUA_PELO_WALLET_ID/transactions",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/deposits", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/deposits');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/deposits",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/deposits/SUBSTITUA_PELO_DEPOSIT_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/deposits/SUBSTITUA_PELO_DEPOSIT_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/deposits/SUBSTITUA_PELO_DEPOSIT_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/withdrawals/quote", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "network": "BSC",
    "asset": "USDT_BSC",
    "destination_address": "SUBSTITUA_PELO_ENDERECO_BSC",
    "amount_units": "1000000",
    "amount_mode": "GROSS"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/withdrawals/quote');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "network": "BSC",
    "asset": "USDT_BSC",
    "destination_address": "SUBSTITUA_PELO_ENDERECO_BSC",
    "amount_units": "1000000",
    "amount_mode": "GROSS"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "network": "BSC",
    "asset": "USDT_BSC",
    "destination_address": "SUBSTITUA_PELO_ENDERECO_BSC",
    "amount_units": "1000000",
    "amount_mode": "GROSS"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/withdrawals/quote",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/withdrawals", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "quote_id": "00000000-0000-4000-8000-000000000002"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/withdrawals');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "quote_id": "00000000-0000-4000-8000-000000000002"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "quote_id": "00000000-0000-4000-8000-000000000002"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/withdrawals",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/withdrawals/SUBSTITUA_PELO_WITHDRAWAL_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/withdrawals/SUBSTITUA_PELO_WITHDRAWAL_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/withdrawals/SUBSTITUA_PELO_WITHDRAWAL_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/swaps/quote", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "asset_in": "USDT_TRC20",
    "asset_out": "USDT_BSC",
    "amount_in_units": "1000000",
    "slippage_bps": 50
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/swaps/quote');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "asset_in": "USDT_TRC20",
    "asset_out": "USDT_BSC",
    "amount_in_units": "1000000",
    "slippage_bps": 50
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "asset_in": "USDT_TRC20",
    "asset_out": "USDT_BSC",
    "amount_in_units": "1000000",
    "slippage_bps": 50
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/swaps/quote",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/swaps", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "quote_id": "00000000-0000-4000-8000-000000000003"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/swaps');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "quote_id": "00000000-0000-4000-8000-000000000003"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "quote_id": "00000000-0000-4000-8000-000000000003"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/swaps",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/swaps/SUBSTITUA_PELO_SWAP_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/swaps/SUBSTITUA_PELO_SWAP_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/swaps/SUBSTITUA_PELO_SWAP_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/internal-transfers", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "recipient_custody_subject": "usuario_00000002",
    "network": "TRON",
    "asset": "USDT_TRC20",
    "amount_units": "1000000"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/internal-transfers');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "recipient_custody_subject": "usuario_00000002",
    "network": "TRON",
    "asset": "USDT_TRC20",
    "amount_units": "1000000"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "recipient_custody_subject": "usuario_00000002",
    "network": "TRON",
    "asset": "USDT_TRC20",
    "amount_units": "1000000"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/internal-transfers",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/conversions/capabilities", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/conversions/capabilities');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/conversions/capabilities",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/conversions/markets", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/conversions/markets');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/conversions/markets",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/conversions", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/conversions');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/conversions",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/conversions/deposit-address", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "asset": "USDT",
    "network": "TRX"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/conversions/deposit-address');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "asset": "USDT",
    "network": "TRX"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "asset": "USDT",
    "network": "TRX"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/conversions/deposit-address",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/conversion-operations", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/conversion-operations');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/conversion-operations",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/conversions/quote", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "direction": "FIAT_TO_CRYPTO",
    "asset": "USDT",
    "network": "TRX",
    "brl_amount_minor": "10000",
    "destination_address": "SUBSTITUA_PELO_ENDERECO_TRC20"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/conversions/quote');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "direction": "FIAT_TO_CRYPTO",
    "asset": "USDT",
    "network": "TRX",
    "brl_amount_minor": "10000",
    "destination_address": "SUBSTITUA_PELO_ENDERECO_TRC20"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "direction": "FIAT_TO_CRYPTO",
    "asset": "USDT",
    "network": "TRX",
    "brl_amount_minor": "10000",
    "destination_address": "SUBSTITUA_PELO_ENDERECO_TRC20"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/conversions/quote",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/conversions/SUBSTITUA_PELO_CONVERSION_ID/confirm", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/conversions/SUBSTITUA_PELO_CONVERSION_ID/confirm');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/crypto/conversions/SUBSTITUA_PELO_CONVERSION_ID/confirm",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/crypto/conversions/SUBSTITUA_PELO_CONVERSION_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/crypto/conversions/SUBSTITUA_PELO_CONVERSION_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/crypto/conversions/SUBSTITUA_PELO_CONVERSION_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/products", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/products');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/cards/products",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/rates", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/rates');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/cards/rates",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/capabilities", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/cards/capabilities');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/cards/capabilities",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'X-Vexus-External-User-Id: witevexus:user:1001',
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/cards",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "product_code": "vexus_international",
    "amount": "10.00",
    "name_on_card": "CLIENTE EXEMPLO",
    "external_user_id": "witevexus:user:1001"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'X-Vexus-External-User-Id: witevexus:user:1001',
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "product_code": "vexus_international",
    "amount": "10.00",
    "name_on_card": "CLIENTE EXEMPLO",
    "external_user_id": "witevexus:user:1001"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "product_code": "vexus_international",
    "amount": "10.00",
    "name_on_card": "CLIENTE EXEMPLO",
    "external_user_id": "witevexus:user:1001"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/cards",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'X-Vexus-External-User-Id: witevexus:user:1001',
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID", {
  method: 'DELETE',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'X-Vexus-External-User-Id: witevexus:user:1001',
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'DELETE',
    "https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/fund", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": "10.00"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/fund');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'X-Vexus-External-User-Id: witevexus:user:1001',
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "amount": "10.00"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "amount": "10.00"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/fund",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/freeze", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/freeze');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'X-Vexus-External-User-Id: witevexus:user:1001',
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/freeze",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/unfreeze", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/unfreeze');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'X-Vexus-External-User-Id: witevexus:user:1001',
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/unfreeze",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/transactions", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/transactions');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'X-Vexus-External-User-Id: witevexus:user:1001',
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/transactions",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/display-sessions", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "allowed_origin": "https://witevexus.fun",
    "external_user_id": "witevexus:user:1001"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/display-sessions');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'X-Vexus-External-User-Id: witevexus:user:1001',
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "allowed_origin": "https://witevexus.fun",
    "external_user_id": "witevexus:user:1001"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "allowed_origin": "https://witevexus.fun",
    "external_user_id": "witevexus:user:1001"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/cards/SUBSTITUA_PELO_CARD_ID/display-sessions",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/webhooks", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/webhooks');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/cards/webhooks",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/cards/webhooks", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "label": "OTP produção",
    "url": "https://api.exemplo.com/webhooks/vexus"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/cards/webhooks');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "label": "OTP produção",
    "url": "https://api.exemplo.com/webhooks/vexus"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "label": "OTP produção",
    "url": "https://api.exemplo.com/webhooks/vexus"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/cards/webhooks",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/rotate-secret", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/rotate-secret');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/rotate-secret",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/activate", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/activate');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/activate",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/deactivate", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/deactivate');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/cards/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/deactivate",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/account/limits", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/account/limits');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/account/limits",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/account/fees", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/account/fees');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/account/fees",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/account/operations/by-idempotency/SUBSTITUA_PELO_IDEMPOTENCY_KEY", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/account/operations/by-idempotency/SUBSTITUA_PELO_IDEMPOTENCY_KEY');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'X-Vexus-External-User-Id: witevexus:user:1001',
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'X-Vexus-External-User-Id': 'witevexus:user:1001',
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/account/operations/by-idempotency/SUBSTITUA_PELO_IDEMPOTENCY_KEY",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/account/ted", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/account/ted');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/account/ted",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/account/balance", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/account/balance');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/account/balance",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/account/transactions", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/account/transactions');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/account/transactions",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/nominal",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/ted", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/ted');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/nominal/ted",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/balance", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/balance');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/nominal/balance",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/transactions", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/transactions');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/nominal/transactions",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/pix-key", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/pix-key');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/nominal/pix-key",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/operations/SUBSTITUA_PELO_OPERATION_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/operations/SUBSTITUA_PELO_OPERATION_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/nominal/operations/SUBSTITUA_PELO_OPERATION_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/balance", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/balance');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/balance",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/pix-key", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/pix-key');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/nominal/pix-key",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/qr/dynamic", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/qr/dynamic');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/nominal/qr/dynamic",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/qr/static", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/qr/static');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/nominal/qr/static",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/qr/decode", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/qr/decode');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/nominal/qr/decode",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/qr/pay", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/qr/pay');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/nominal/qr/pay",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/pix-out", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/nominal/pix-out');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/nominal/pix-out",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/white-label",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/plan", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/plan');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/white-label/plan",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/fees", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/fees');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/white-label/fees",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/billing", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/billing');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/white-label/billing",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/status", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/status');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/white-label/status",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/nominal", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/nominal');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/white-label/nominal",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/nominal", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "reason": "Conta operacional da minha marca para recebimentos PIX."
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/nominal');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "reason": "Conta operacional da minha marca para recebimentos PIX."
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "reason": "Conta operacional da minha marca para recebimentos PIX."
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/white-label/nominal",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/nominal/bind", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "nominal_user_id": 1001,
    "external_subject": "cliente:1001"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/nominal/bind');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "nominal_user_id": 1001,
    "external_subject": "cliente:1001"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "nominal_user_id": 1001,
    "external_subject": "cliente:1001"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/white-label/nominal/bind",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/nominal/SUBSTITUA_PELO_REQUEST_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/nominal/SUBSTITUA_PELO_REQUEST_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/white-label/nominal/SUBSTITUA_PELO_REQUEST_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/white-label/nominal/SUBSTITUA_PELO_REQUEST_ID", {
  method: 'DELETE',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/white-label/nominal/SUBSTITUA_PELO_REQUEST_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'DELETE',
    "https://sandbox-api.example.invalid/api/v1/white-label/nominal/SUBSTITUA_PELO_REQUEST_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/tickets", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/tickets');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/support/tickets",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/tickets", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "category": "IMPLEMENTATION",
    "subject": "Dúvida na integração PIX",
    "message": "Precisamos validar o tratamento do retorno assíncrono da nossa integração.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/tickets');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "category": "IMPLEMENTATION",
    "subject": "Dúvida na integração PIX",
    "message": "Precisamos validar o tratamento do retorno assíncrono da nossa integração.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "category": "IMPLEMENTATION",
    "subject": "Dúvida na integração PIX",
    "message": "Precisamos validar o tratamento do retorno assíncrono da nossa integração.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/support/tickets",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID/messages", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "message": "Aplicamos o ajuste e enviamos um novo correlation ID para análise.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID/messages');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "message": "Aplicamos o ajuste e enviamos um novo correlation ID para análise.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "message": "Aplicamos o ajuste e enviamos um novo correlation ID para análise.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID/messages",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID/close", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID/close');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/support/tickets/SUBSTITUA_PELO_TICKET_ID/close",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';
import { readFile } from 'node:fs/promises';

const idempotencyKey = crypto.randomUUID();

const image = await readFile('/caminho/para/evidencia.png');
const form = new FormData();
form.append('file', new Blob([image], { type: 'image/png' }), 'evidencia.png');

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/attachments", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
  },
  body: form,
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/attachments');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    ],
    CURLOPT_POSTFIELDS => ['file' => new CURLFile('/caminho/para/evidencia.png', 'image/png', 'evidencia.png')],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
}
image_file = open('/caminho/para/evidencia.png', 'rb')
files = {'file': ('evidencia.png', image_file, 'image/png')}
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/support/attachments",
    headers=headers,
    files=files,
    timeout=30,
)
image_file.close()
response.raise_for_status()
print(response.json())

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/attachments/SUBSTITUA_PELO_ATTACHMENT_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
const imageBytes = Buffer.from(await response.arrayBuffer());
console.log(response.headers.get('content-type'), imageBytes.length);

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/attachments/SUBSTITUA_PELO_ATTACHMENT_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

file_put_contents('/caminho/para/anexo-suporte', $response);

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/support/attachments/SUBSTITUA_PELO_ATTACHMENT_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
with open('./anexo-suporte', 'wb') as output:
    output.write(response.content)

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/webhooks", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/webhooks');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://api.nodexhub.com.br/api/v1/support/webhooks",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/webhooks", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "label": "Suporte produção",
    "url": "https://api.exemplo.com/webhooks/vexus/support",
    "events": [
        "support.message.created",
        "support.ticket.status_changed",
        "support.ticket.closed"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/webhooks');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "label": "Suporte produção",
    "url": "https://api.exemplo.com/webhooks/vexus/support",
    "events": [
        "support.message.created",
        "support.ticket.status_changed",
        "support.ticket.closed"
    ]
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "label": "Suporte produção",
    "url": "https://api.exemplo.com/webhooks/vexus/support",
    "events": [
        "support.message.created",
        "support.ticket.status_changed",
        "support.ticket.closed"
    ]
}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/support/webhooks",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/rotate-secret", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/rotate-secret');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/rotate-secret",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/activate", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/activate');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/activate",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/deactivate", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/deactivate');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://api.nodexhub.com.br/api/v1/support/webhooks/SUBSTITUA_PELO_WEBHOOK_ID/deactivate",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits/rules", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits/rules');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/splits/rules",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits/rules", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "name": "Parceiros",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "conta-parceira",
            "percentage": "20.00"
        }
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits/rules');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "name": "Parceiros",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "conta-parceira",
            "percentage": "20.00"
        }
    ]
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "name": "Parceiros",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "conta-parceira",
            "percentage": "20.00"
        }
    ]
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/splits/rules",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits/rules/SUBSTITUA_PELO_RULE_ID", {
  method: 'PUT',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "name": "Parceiros v2",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "conta-parceira",
            "percentage": "25.00"
        }
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits/rules/SUBSTITUA_PELO_RULE_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'PUT',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "name": "Parceiros v2",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "conta-parceira",
            "percentage": "25.00"
        }
    ]
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "name": "Parceiros v2",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "conta-parceira",
            "percentage": "25.00"
        }
    ]
}
''')
response = requests.request(
    'PUT',
    "https://sandbox-api.example.invalid/api/v1/splits/rules/SUBSTITUA_PELO_RULE_ID",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits/rules/SUBSTITUA_PELO_RULE_ID", {
  method: 'DELETE',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits/rules/SUBSTITUA_PELO_RULE_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'DELETE',
    "https://sandbox-api.example.invalid/api/v1/splits/rules/SUBSTITUA_PELO_RULE_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "rule_id": "00000000-0000-4000-8000-000000000001",
    "amount": 100,
    "payer": {
        "name": "Cliente de Exemplo",
        "document": "52998224725",
        "email": "cliente@example.com"
    }
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "rule_id": "00000000-0000-4000-8000-000000000001",
    "amount": 100,
    "payer": {
        "name": "Cliente de Exemplo",
        "document": "52998224725",
        "email": "cliente@example.com"
    }
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "rule_id": "00000000-0000-4000-8000-000000000001",
    "amount": 100,
    "payer": {
        "name": "Cliente de Exemplo",
        "document": "52998224725",
        "email": "cliente@example.com"
    }
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/splits",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID/cancel", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID/cancel');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID/cancel",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID/refund", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": 25,
    "comment": "Devolução parcial solicitada pelo cliente"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID/refund');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "amount": 25,
    "comment": "Devolução parcial solicitada pelo cliente"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "amount": 25,
    "comment": "Devolução parcial solicitada pelo cliente"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/splits/SUBSTITUA_PELO_SPLIT_ID/refund",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/splits/report", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/splits/report');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/splits/report",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/workspace", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/workspace');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/sandbox/workspace",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/faucet", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "asset": "USDT_BEP20",
    "amount": "25.00"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/faucet');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "asset": "USDT_BEP20",
    "amount": "25.00"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "asset": "USDT_BEP20",
    "amount": "25.00"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/sandbox/faucet",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/reset", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "confirmation": "RESET_SANDBOX"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/reset');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "confirmation": "RESET_SANDBOX"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "confirmation": "RESET_SANDBOX"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/sandbox/reset",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/resources/SUBSTITUA_PELO_RESOURCE_TYPE/SUBSTITUA_PELO_RESOURCE_ID/actions", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "action": "APPROVE"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/resources/SUBSTITUA_PELO_RESOURCE_TYPE/SUBSTITUA_PELO_RESOURCE_ID/actions');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "action": "APPROVE"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "action": "APPROVE"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/sandbox/resources/SUBSTITUA_PELO_RESOURCE_TYPE/SUBSTITUA_PELO_RESOURCE_ID/actions",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/crypto/deposits", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "wallet_id": "00000000-0000-4000-8000-000000000003",
    "amount": "10.00",
    "confirmations": 0
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/crypto/deposits');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "wallet_id": "00000000-0000-4000-8000-000000000003",
    "amount": "10.00",
    "confirmations": 0
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "wallet_id": "00000000-0000-4000-8000-000000000003",
    "amount": "10.00",
    "confirmations": 0
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/sandbox/crypto/deposits",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/cards/SUBSTITUA_PELO_CARD_ID/transactions", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": "12.50",
    "currency": "USD",
    "outcome": "APPROVED"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/cards/SUBSTITUA_PELO_CARD_ID/transactions');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "amount": "12.50",
    "currency": "USD",
    "outcome": "APPROVED"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "amount": "12.50",
    "currency": "USD",
    "outcome": "APPROVED"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/sandbox/cards/SUBSTITUA_PELO_CARD_ID/transactions",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/cards/SUBSTITUA_PELO_CARD_ID/otp", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "wallet_type": "GOOGLE_PAY"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/cards/SUBSTITUA_PELO_CARD_ID/otp');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{
    "wallet_type": "GOOGLE_PAY"
}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{
    "wallet_type": "GOOGLE_PAY"
}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/sandbox/cards/SUBSTITUA_PELO_CARD_ID/otp",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/webhook-deliveries", {
  method: 'GET',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
  },
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/webhook-deliveries');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    ],
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
}
response = requests.request(
    'GET',
    "https://sandbox-api.example.invalid/api/v1/sandbox/webhook-deliveries",
    headers=headers,
    timeout=30,
)
response.raise_for_status()
print(response.json())

import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/webhook-deliveries/SUBSTITUA_PELO_DELIVERY_ID/retry", {
  method: 'POST',
  headers: {
    'Apikey': process.env.VEXUS_CLIENT_ID,
    'X-Client-Secret': process.env.VEXUS_CLIENT_SECRET,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());

$idempotencyKey = bin2hex(random_bytes(16));

$ch = curl_init('https://sandbox-api.example.invalid/api/v1/sandbox/webhook-deliveries/SUBSTITUA_PELO_DELIVERY_ID/retry');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
    'Apikey: ' . getenv('VEXUS_CLIENT_ID'),
    'X-Client-Secret: ' . getenv('VEXUS_CLIENT_SECRET'),
    'Idempotency-Key: ' . $idempotencyKey,
    'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => <<<'JSON'
{}
JSON,
]);

$response = curl_exec($ch);
$httpStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($response === false) throw new RuntimeException(curl_error($ch));
curl_close($ch);
if ($httpStatus >= 400) throw new RuntimeException("HTTP {$httpStatus}");

var_dump(json_decode($response, true, 512, JSON_THROW_ON_ERROR));

import os
import requests
import json
import uuid

idempotency_key = str(uuid.uuid4())

headers = {
    'Apikey': os.environ['VEXUS_CLIENT_ID'],
    'X-Client-Secret': os.environ['VEXUS_CLIENT_SECRET'],
    'Idempotency-Key': idempotency_key,
    'Content-Type': 'application/json',
}
payload = json.loads(r'''
{}
''')
response = requests.request(
    'POST',
    "https://sandbox-api.example.invalid/api/v1/sandbox/webhook-deliveries/SUBSTITUA_PELO_DELIVERY_ID/retry",
    headers=headers,
    json=payload,
    timeout=30,
)
response.raise_for_status()
print(response.json())