VexusPayDocumentación oficial
API operativa
PT EN ES
VEXUS PUBLIC API · 2026-09-15

Una API financiera lista para su próxima gran integración.

Conecte Pix, boleto, checkout, cripto, tarjetas y Split Payment con contratos estables, seguridad y visibilidad en cada etapa.

Comenzar integración Descargar Postman
Contrato OpenAPI Webhooks firmados Sandbox público y aislado
Ilustración de la infraestructura de pagos VexusPay
Sandbox Producción
Base URL de producción — mueve valores realeshttps://api.nodexhub.com.br
Ecosistema de API VexusPay para pagos, tarjetas, boleto, cripto y Split
Entorno de pruebas

Sandbox completo y aislado

Sandbox públicoUse https://sandbox-api.vexuspay.com.br para probar el contrato publicado sin mover fondos reales. Las credenciales de Producción nunca funcionan en Sandbox y las credenciales Sandbox nunca funcionan en Producción.

Cree una credencial marcada como Sandbox en Configuración → Credenciales. Su identificador comienza por vx_sbx_. El workspace aislado tiene saldos, recursos, registros de idempotencia y entregas de webhook simulados; nunca llama a un proveedor financiero.

01

Saldo simulado

Use GET /api/v1/sandbox/workspace, el faucet y el endpoint de reset para organizar pruebas deterministas.

02

Transiciones realistas

Cree recursos mediante sus rutas normales y use Sandbox Controls para aprobar, fallar, expirar o revertir operaciones simuladas pendientes.

03

Webhooks separados

Los endpoints, intentos de entrega y firmas de Sandbox nunca comparten estado con Producción. Los payloads OTP permanecen cifrados y se redactan en la auditoría.

Escenarios de errorSolo en Sandbox, envíe X-Vexus-Sandbox-Scenario con success, insufficient_balance, provider_timeout, rate_limited, declined, expired o webhook_retry. Producción rechaza este header.
01

HTTPS + JSON

Contratos estables, respuestas estructuradas y ejemplos listos para el backend.

02

Idempotencia

Reintentos seguros de operaciones financieras sin movimientos duplicados.

03

Webhooks firmados

Entrega autenticada, identificadores de evento estables y reintentos controlados.

Motivos

Autenticación servidor a servidor

Las rutas privadas exigen las dos credenciales indicadas abajo. Envíelas únicamente desde su backend. Nunca exponga el Client Secret en código del navegador, una aplicación móvil, una URL, una solicitud de soporte ni logs.

Headers obligatorios
Apikey: TU_CLIENT_ID
X-Client-Secret: TU_CLIENT_SECRET
Content-Type: application/json
01

Cree la credencial

Seleccione el entorno correcto y conceda únicamente los scopes necesarios. El Client Secret se muestra una sola vez al crearlo o rotarlo; guárdelo inmediatamente en un almacén de secretos.

02

Habilite producto y scope

El acceso al producto y el scope de la credencial son verificaciones independientes. HTTP 403 puede indicar que falta uno de ellos aunque la credencial sea válida.

03

Restrinja el origen

Si se utiliza una allowlist de IP, registre la IP pública de salida de su backend. No llame rutas privadas directamente desde el navegador ni desde una aplicación móvil.

El PIN es un secreto del panelEl PIN de seis dígitos solo autoriza acciones administrativas del panel, como crear una credencial. Nunca lo envíe a la aplicación integradora, a una IA, al navegador ni a una llamada de API. El backend utiliza únicamente Apikey y X-Client-Secret.
Titularidad de la integraciónEl nombre y el dominio de una credencial no cambian la cuenta propietaria. En Producción, use una cuenta empresarial exclusiva o autorice formalmente compartir la cuenta titular. Productos, saldos, límites, tarifas, operaciones y callbacks se aíslan por cuenta y credencial.
Confiabilidad

Idempotencia

Su backend crea una Idempotency-Key de 8–100 caracteres para cada nueva intención de negocio mutable. Conserve método, URL, body, bytes del archivo y clave exactos para los reintentos. Un body diferente con la misma clave devuelve conflicto; una intención nueva siempre exige una clave nueva.

1

Genere una clave

Use un UUID aleatorio antes de la primera solicitud.

2

Envíela en el header

Inclúyala junto con las credenciales y el payload.

3

Consulte la intención

Sin respuesta concluyente, llame GET /api/v1/account/operations/by-idempotency/{idempotencyKey}?operation=... con la misma credencial.

4

Concilie antes de reemplazar

Cree una clave nueva únicamente cuando la intención original sea terminal o haya fallado de forma definitiva.

Confiabilidad

Errores y reintentos

Los errores JSON incluyen code estable, message legible, details, correlationId y retryable. Guarde el correlation ID, nunca credenciales ni bodies sensibles.

4xx

Corrija o consulte el estado

400/413/415/422 indican entrada inválida. 401 indica error de autenticación; 403, error de autorización. 404 también protege el aislamiento entre cuentas. Ante 409, consulte el recurso existente o la intención original.

429

Respete Retry-After

Espere el tiempo de Retry-After y aplique backoff exponencial con jitter. Un reintento debe conservar la Idempotency-Key y el body originales.

5xx

Falle de forma cerrada

No presuma éxito ni fallo tras un timeout o 5xx. Consulte la Idempotency-Key original antes de cualquier nuevo POST. Si el estado sigue inconcluso, manténgalo en revisión y contacte con soporte usando el correlationId.

Aceptación asíncronaHTTP 201/202 puede indicar creación o admisión, no liquidación PIX ni confirmación blockchain. Persista los IDs devueltos y acompañe el recurso mediante consulta y webhook hasta un estado terminal.
Criptomonedas

Flujo de billetera, depósito y transferencia

Use las mismas credenciales servidor a servidor de los otros módulos. Consulte siempre redes, activos, pares de swap y capacidades de conversión antes de mostrar una acción: el catálogo es la fuente de verdad de la disponibilidad actual.

  1. 1
    Cree u obtenga la billetera

    La creación es idempotente por cuenta y red. Para custodia individual White Label, envíe X-Vexus-Custody-Subject con un ID de usuario opaco e inmutable. Para custodia central, envíe únicamente X-Vexus-Custody-Access: CENTRAL. Estos headers son mutuamente excluyentes.

  2. 2
    Reciba y supervise depósitos

    Use la dirección de la billetera y acompañe las confirmaciones y el estado del depósito. HTTP 200 o CREDITED no sustituye la espera del estado terminal documentado.

  3. 3
    Cotice antes de cada acción mutable

    Los importes terminados en _units o _minor son cadenas enteras en la unidad mínima, nunca valores de punto flotante. Las cotizaciones definen tarifas, límites ejecutables y vencimiento.

  4. 4
    Confirme una vez y concilie

    Use una Idempotency-Key nueva para confirmar, persista el ID devuelto y acompañe el recurso hasta un estado terminal. En modo GROSS, las tarifas se descuentan del límite autorizado; en modo NET, pueden aumentar el débito total.

Disponibilidad actual de conversiónBRL a cripto exige destino externo y capacidad habilitada. Cripto a BRL permanece en mantenimiento: no envíe cotizaciones ni confirmaciones nuevas hasta que el endpoint de capabilities indique que está disponible.
Canal operativo

API de soporte

Cualquier cuenta activa de Producción con producto support y scope support.manage puede integrar el soporte VexusPay en su backend. La credencial autenticada determina la cuenta; no se acepta un ID de cliente/cuenta en el body y nunca se revelan recursos de otra cuenta.

01

Tickets y mensajes

Cree, liste, consulte, responda y cierre tickets mediante las rutas publicadas. Todas las escrituras exigen Idempotency-Key.

02

Imágenes privadas

Cargue JPEG, PNG o WebP en el campo multipart file. El máximo es 5 MiB por imagen y cuatro adjuntos por mensaje. Cada descarga exige credenciales API y debe pasar por su backend.

03

Eventos firmados

Registre un endpoint HTTPS para eventos de soporte. El secreto de firma se devuelve una sola vez y debe guardarse en un almacén de secretos; nunca vuelve a mostrarse.

Seguridad del navegadorNunca envíe Apikey, X-Client-Secret, secretos de firma ni URL autenticadas de adjuntos al navegador. Use su backend como límite de confianza.
Eventos

Webhooks firmados

Lea y conserve el body sin procesar antes de interpretar el JSON. Calcule HMAC-SHA256(timestamp + "." + rawBody, signing_secret), compare en tiempo constante con X-Vexus-Signature, rechace timestamps antiguos y deduplique por event_id y X-Vexus-Delivery.

Headers de entrega
X-Vexus-Event: <event_name>
X-Vexus-Delivery: <uuid>
X-Vexus-Timestamp: <unix_timestamp>
X-Vexus-Signature: v1=<hmac_sha256>
Confirmación rápidaPersista el evento verificado, responda 2xx rápidamente y procéselo en una cola interna. Los fallos de transporte, 408, 409, 425, 429 y 5xx se reintentan. Un evento duplicado nunca debe iniciar una segunda operación financiera.
Referencia completa

Criterios publicados

Los ejemplos abajo son derivados del mismo contrato que genera OpenAPI y la colección Postman.

Módulo

Estado

Disponibilidad técnica sin autenticación.

GET /health/live Público

Disponibilidad del proceso

Comprueba si el proceso HTTP está activo.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/health/live", {
  method: 'GET',
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
GET /health/ready Público

Preparación del servicio

Valida la base de datos, las migraciones y las dependencias internas necesarias para recibir tráfico.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/health/ready", {
  method: 'GET',
});

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

PIX

Entrada, salida, decodificación y pago mediante código QR PIX.

Flujo de la API PIX VexusPay, de la recaudación al webhook de confirmación
POST /api/v1/cashin Credenciales Scope: cashin Producto: pix.cash_in

Crear cobro PIX

Crea un cobro PIX dinámico.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "amount": 25.9
}
POST /api/v1/cashout Credenciales Scope: cashout Producto: pix.cash_out

Enviar PIX

Envía un pago PIX a la clave indicada, sujeto al saldo, al producto habilitado y a los límites de la cuenta.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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": "<clave-pix-destino>",
    "pix_key_type": "random",
    "description": "Transferencia de fondos"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "amount": 20,
    "pix_key": "<clave-pix-destino>",
    "pix_key_type": "random",
    "description": "Transferencia de fondos"
}
POST /api/v1/pix/qr/decode Credenciales Scope: cashout Producto: pix.cash_out

Decodificar código QR PIX

Valida el CRC y decodifica un payload EMV PIX estático o dinámico sin mover fondos. La respuesta indica si el importe está fijado en el código QR.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "payload": "00020101021226810014br.gov.bcb.pix2559https://example.invalid/pix/cobranca-exemplo520400005303986540539.905802BR5905VEXUS6009SAO PAULO62070503***6304B9CE"
}
POST /api/v1/pix/qr/pay Credenciales Scope: cashout Producto: pix.cash_out

Pagar código QR PIX

Paga un código QR PIX después de validar el CRC, el importe declarado, el saldo y los límites. El importe incluido en el código QR siempre prevalece sobre el enviado por el integrador.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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": "Proveedor"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "payload": "00020101021226810014br.gov.bcb.pix2559https://example.invalid/pix/cobranca-exemplo520400005303986540539.905802BR5905VEXUS6009SAO PAULO62070503***6304B9CE",
    "description": "Proveedor"
}
Módulo

Boleto

Emisión, consulta y pago de boleto.

Flujo de la API de boleto VexusPay, emisión al pago
POST /api/v1/boleto/issue Credenciales Scope: boleto Producto: boleto

Emitir boleto

Emite un cobro por boleto sin exigir un artículo del catálogo de Checkout. El producto de API boleto debe estar habilitado. El nombre, CPF/CNPJ y correo se obtienen del registro de la cuenta; la dirección no es obligatoria.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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": "Cobro mediante boleto"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "amount": 99.9,
    "due_date": "2026-09-30",
    "description": "Cobro mediante boleto"
}
POST /api/v1/boleto/info Credenciales Scope: boleto Producto: boleto

Consultar boleto

Consulta al proveedor el importe actualizado y los datos del beneficiario sin mover fondos.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "billetCode": "00190000000000014990000000000000000000000000"
}
POST /api/v1/boleto/pay Credenciales Scope: boleto Producto: boleto

Pagar boleto

Vuelve a consultar al proveedor el importe y el beneficiario, y valida el saldo y los límites antes del pago. El integrador envía únicamente el código del boleto.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "billetCode": "00190000000000014990000000000000000000000000"
}
Módulo

Checkout

Catálogo, enlaces de pago, medios habilitados e informes de Checkout.

Flujo de la API de tarjeta VexusPay del checkout a la confirmación
POST /api/v1/card/config Solo producción Credenciales Scope: cards.write Producto: card PUBLISHED PRODUCTION ONLY

Obtener configuración de tokenización

Devuelve la clave pública y la URL del SDK autorizado para tokenizar la tarjeta en el navegador. Nunca envíe PAN ni CVV al backend de VexusPay.

Ejemplos de integración
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());
Ver corpo de exemplo 
{}
POST /api/v1/card/pay Solo producción Credenciales Scope: cards.write Producto: card PUBLISHED PRODUCTION ONLY

Procesar pago con tarjeta

Procesa un cobro independiente sin exigir un artículo del catálogo de Checkout. El producto de API card debe estar habilitado. Use un token de tarjeta de un solo uso creado por el SDK indicado por el endpoint de configuración; no se aceptan PAN ni CVV.

Exige Idempotency-Key.
Ejemplos de integración
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-ejemplo-123",
    "buyer_name": "Cliente de Ejemplo",
    "buyer_email": "cliente@example.com",
    "buyer_cpf": "52998224725",
    "card_token": "REEMPLACE_CON_TOKEN_DE_UN_SOLO_USO",
    "payment_method_id": "visa",
    "installments": 1,
    "description": "Pedido de ejemplo 123"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "amount": 99.9,
    "external_id": "pedido-ejemplo-123",
    "buyer_name": "Cliente de Ejemplo",
    "buyer_email": "cliente@example.com",
    "buyer_cpf": "52998224725",
    "card_token": "REEMPLACE_CON_TOKEN_DE_UN_SOLO_USO",
    "payment_method_id": "visa",
    "installments": 1,
    "description": "Pedido de ejemplo 123"
}
GET /api/v1/checkout/methods Credenciales Scope: checkout Producto: checkout

Listar medios de checkout

Devuelve únicamente los medios de pago homologados y disponibles para la cuenta autenticada.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/checkout/report Credenciales Scope: checkout Producto: checkout

Consultar informe de checkout

Devuelve métricas agregadas de los enlaces de pago y pedidos de la cuenta autenticada.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/checkout/products Credenciales Scope: checkout Producto: checkout

Listar productos de checkout

Lista los productos activos y archivados del catálogo de la cuenta.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/checkout/products Credenciales Scope: checkout Producto: checkout

Crear producto de checkout

Crea un producto del catálogo. Un medio que exige identificación externa del producto solo puede habilitarse cuando se informa provider_product_id.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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": "Plan mensual",
    "price": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "name": "Plan mensual",
    "price": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}
GET /api/v1/checkout/products/{productId} Credenciales Scope: checkout Producto: checkout

Consultar producto de checkout

Devuelve un producto del catálogo perteneciente a la cuenta autenticada.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/checkout/products/REEMPLAZA_CON_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());
PUT /api/v1/checkout/products/{productId} Credenciales Scope: checkout Producto: checkout

Actualizar producto de checkout

Actualiza una versión del producto. Envíe la version devuelta por el endpoint de consulta para impedir sobrescrituras concurrentes.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/checkout/products/REEMPLAZA_CON_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": "Plan mensual actualizado",
    "price": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "name": "Plan mensual actualizado",
    "price": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}
DELETE /api/v1/checkout/products/{productId} Credenciales Scope: checkout Producto: checkout

Archivar producto de checkout

Archiva el producto y sus enlaces activos. Exige Idempotency-Key y no acepta body.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/checkout/products/REEMPLAZA_CON_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());
GET /api/v1/checkout/links Credenciales Scope: checkout Producto: checkout

Listar enlaces de checkout

Lista los enlaces de pago, sus estados y métricas para la cuenta autenticada.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/checkout/links Credenciales Scope: checkout Producto: checkout

Crear enlace de checkout

Crea un enlace independiente o asociado a un producto. Combine el payment_path devuelto con el dominio VexusPay de la cuenta.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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": "Pago de servicio",
    "amount": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "title": "Pago de servicio",
    "amount": "49.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ]
}
GET /api/v1/checkout/links/{linkId} Credenciales Scope: checkout Producto: checkout

Consultar enlace de checkout

Devuelve la configuración y el payment_path de un enlace perteneciente a la cuenta autenticada.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/checkout/links/REEMPLAZA_CON_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());
PUT /api/v1/checkout/links/{linkId} Credenciales Scope: checkout Producto: checkout

Actualizar enlace de checkout

Actualiza una versión del enlace. Envíe la version devuelta por el endpoint de consulta para impedir sobrescrituras concurrentes.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/checkout/links/REEMPLAZA_CON_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": "Pago de servicio actualizado",
    "amount": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "title": "Pago de servicio actualizado",
    "amount": "59.90",
    "currency": "BRL",
    "payment_methods": [
        "PIX"
    ],
    "version": 1
}
POST /api/v1/checkout/links/{linkId}/archive Credenciales Scope: checkout Producto: checkout

Archivar enlace de checkout

Archiva el enlace e impide nuevos pagos. Exige Idempotency-Key y no acepta body.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/checkout/links/REEMPLAZA_CON_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());
POST /api/v1/checkout/links/{linkId}/cancel Credenciales Scope: checkout Producto: checkout

Cancelar enlace de checkout

Cancela el enlace con un motivo auditable e impide nuevos pagos. Exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/checkout/links/REEMPLAZA_CON_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": "Cancelación solicitada por el cliente"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "reason": "Cancelación solicitada por el cliente"
}
Módulo

Cripto

Catálogo, billeteras, saldos, depósitos, retiros, swaps, transferencias internas y conversiones según las capacidades actuales.

Flujo de la API de cripto VexusPay de la cartera a la conversión
GET /api/v1/crypto/networks Credenciales Scope: cashin Producto: crypto

Listar redes cripto

Lista BSC y TRON con su estado de mantenimiento y sus capacidades de depósito, retiro y swap.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/crypto/assets Credenciales Scope: cashin Producto: crypto

Listar activos cripto

Lista los activos por red, su precisión decimal y las capacidades habilitadas actualmente.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/crypto/swap-pairs Credenciales Scope: cashin Producto: crypto

Listar pares de swap

Lista los pares disponibles en la misma red y el par cross-chain USDT TRC-20 ↔ USDT BEP-20.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/crypto/wallets Credenciales Scope: cashin Producto: crypto

Listar billeteras cripto

Lista únicamente las billeteras de la cuenta o del contexto de custodia autenticado.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/crypto/wallets Credenciales Scope: cashin Producto: crypto

Crear u obtener billetera

Crea o reutiliza de forma idempotente la billetera HD BSC o TRON de la cuenta. Los tokens de la misma red comparten la misma dirección.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "network": "BSC"
}
GET /api/v1/crypto/wallets/{walletId} Credenciales Scope: cashin Producto: crypto

Consultar billetera

Devuelve una billetera Vexus perteneciente a la cuenta autenticada.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/crypto/wallets/REEMPLAZA_CON_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());
GET /api/v1/crypto/wallets/{walletId}/balances Credenciales Scope: cashin Producto: crypto

Consultar saldos de la billetera

Devuelve los saldos contable, disponible, reservado, pendiente y on-chain como cadenas enteras en la unidad mínima del activo.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/crypto/wallets/REEMPLAZA_CON_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());
GET /api/v1/crypto/wallets/{walletId}/transactions Credenciales Scope: cashin Producto: crypto

Listar transacciones de la billetera

Lista los depósitos y retiros recientes de la billetera.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/crypto/wallets/REEMPLAZA_CON_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());
GET /api/v1/crypto/deposits Credenciales Scope: cashin Producto: crypto

Listar depósitos

Lista únicamente los depósitos vinculados a billeteras de la cuenta o del contexto de custodia autenticado.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/crypto/deposits/{depositId} Credenciales Scope: cashin Producto: crypto

Consultar depósito

Devuelve el estado del depósito y la cantidad de confirmaciones. CREDITED o HTTP 200 no sustituye la verificación de un estado terminal.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/crypto/deposits/REEMPLAZA_CON_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());
POST /api/v1/crypto/withdrawals/quote Credenciales Scope: cashout Producto: crypto

Cotizar retiro cripto

Crea una cotización autoritativa con tarifas, importe neto, débito total y validez en *_units. En modo GROSS, el importe informado es el límite autorizado y las tarifas se descuentan de él. Esta llamada no mueve fondos.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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": "REEMPLACE_CON_DIRECCION_BSC",
    "amount_units": "1000000",
    "amount_mode": "GROSS"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "network": "BSC",
    "asset": "USDT_BSC",
    "destination_address": "REEMPLACE_CON_DIRECCION_BSC",
    "amount_units": "1000000",
    "amount_mode": "GROSS"
}
POST /api/v1/crypto/withdrawals Credenciales Scope: cashout Producto: crypto

Ejecutar retiro cripto cotizado

Reserva los fondos y programa el retiro mediante quote_id. HTTP 202 no confirma una transacción blockchain; siga el recurso hasta que alcance un estado terminal.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "quote_id": "00000000-0000-4000-8000-000000000002"
}
GET /api/v1/crypto/withdrawals/{withdrawalId} Credenciales Scope: cashout Producto: crypto

Consultar retiro cripto

Devuelve el estado, el TXID y el costo real de red cuando estén disponibles.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/crypto/withdrawals/REEMPLAZA_CON_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());
POST /api/v1/crypto/swaps/quote Credenciales Scope: cashout Producto: crypto

Cotizar swap cripto

Crea una cotización autoritativa same-chain o cross-chain de USDT usando únicamente los pares publicados.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "asset_in": "USDT_TRC20",
    "asset_out": "USDT_BSC",
    "amount_in_units": "1000000",
    "slippage_bps": 50
}
POST /api/v1/crypto/swaps Credenciales Scope: cashout Producto: crypto

Ejecutar swap cotizado

Reserva los fondos y programa el swap mediante quote_id. HTTP 202 no confirma la liquidación.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "quote_id": "00000000-0000-4000-8000-000000000003"
}
GET /api/v1/crypto/swaps/{swapId} Credenciales Scope: cashout Producto: crypto

Consultar swap

Devuelve los importes realizados, los hashes de transacción y el estado conciliado del swap.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/crypto/swaps/REEMPLAZA_CON_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());
POST /api/v1/crypto/internal-transfers Credenciales Scope: cashout Producto: crypto

Transferir entre usuarios

Liquida entre dos usuarios VexusPay en el ledger de Vexus. No crea una transacción blockchain ni un TXID. Informe exactamente un destinatario: recipient_custody_subject es el modo recomendado para White Labels y debe identificar un subject ACTIVE existente en la misma White Label, sin creación automática; recipient_external_user_id permanece solo por compatibilidad.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "recipient_custody_subject": "usuario_00000002",
    "network": "TRON",
    "asset": "USDT_TRC20",
    "amount_units": "1000000"
}
GET /api/v1/crypto/conversions/capabilities Credenciales Scope: cashin Producto: crypto

Consultar capacidades de conversión

Devuelve las direcciones, los activos, las redes y los controles operativos disponibles sin crear una operación.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/crypto/conversions/markets Credenciales Scope: cashin Producto: crypto

Listar mercados de conversión

Devuelve precios indicativos del socio; no son cotizaciones ejecutables.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/crypto/conversions Credenciales Scope: cashin Producto: crypto

Listar direcciones de conversión

Lista las direcciones externas del socio pertenecientes a la cuenta.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/crypto/conversions/deposit-address Credenciales Scope: cashin Producto: crypto MAINTENANCE

Preparar dirección para venta de cripto

Reservado para el flujo cripto a BRL. Las nuevas ventas están en mantenimiento; no use esta ruta hasta que capabilities indique que la dirección está disponible.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "asset": "USDT",
    "network": "TRX"
}
GET /api/v1/crypto/conversion-operations Credenciales Scope: cashout Producto: crypto

Listar conversiones

Lista las operaciones de conversión del contexto autenticado, incluidos sus estados históricos.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/crypto/conversions/quote Credenciales Scope: cashout Producto: crypto

Cotizar BRL a cripto

Crea una cotización ejecutable FIAT_TO_CRYPTO únicamente cuando capabilities habilita el activo y la red. Se exige un destino externo. CRYPTO_TO_FIAT está en mantenimiento y no se acepta en esta versión del request.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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": "REEMPLACE_CON_DIRECCION_TRC20"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "direction": "FIAT_TO_CRYPTO",
    "asset": "USDT",
    "network": "TRX",
    "brl_amount_minor": "10000",
    "destination_address": "REEMPLACE_CON_DIRECCION_TRC20"
}
POST /api/v1/crypto/conversions/{conversionId}/confirm Credenciales Scope: cashout Producto: crypto

Confirmar conversión

Confirma una cotización FIAT_TO_CRYPTO vigente. HTTP 202 indica únicamente la admisión; siga la conversión hasta que alcance un estado terminal.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/crypto/conversions/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
GET /api/v1/crypto/conversions/{conversionId} Credenciales Scope: cashout Producto: crypto

Consultar conversión

Devuelve el estado auditable de la conversión.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/crypto/conversions/REEMPLAZA_CON_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());
Módulo

Tarjetas

Pagos con tarjeta tokenizada y emisión, consulta, recarga, transacciones y controles de estado de tarjetas virtuales autorizadas.

GET /api/v1/cards/products Credenciales Scope: cards.read Producto: virtual.cards

Listar tipos de tarjeta

Devuelve únicamente los tipos de tarjeta VexusPay habilitados actualmente para emisión. El catálogo es dinámico: no conserve la disponibilidad como autorización permanente. No expone códigos técnicos del emisor.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/cards/rates Credenciales Scope: cards.read Producto: virtual.cards

Consultar tarifas de tarjetas

Devuelve las tarifas comerciales dinámicas de la cuenta para emisión, recarga y procesamiento, con origen GLOBAL, PLAN o USER. Consulte este endpoint antes de iniciar una operación. Las tarifas del emisor se confirman únicamente al confirmar la emisión o la recarga.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/cards/capabilities Solo producción Credenciales Scope: cards.read Producto: virtual.cards PUBLISHED PRODUCTION ONLY

Consultar capacidades de tarjeta virtual

Devuelve las acciones disponibles actualmente para la cuenta e indica si X-Vexus-External-User-Id es obligatorio. Consúltelo inmediatamente antes de mostrar o iniciar una acción; no prometa emisión, recarga ni control cuando la acción correspondiente sea false.

Ejemplos de integración
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());
GET /api/v1/cards Credenciales Scope: cards.read Producto: virtual.cards

Listar tarjetas

Cuando external_user_header_required=true, lista únicamente las tarjetas del usuario externo informado, con saldo, estado, marca y últimos cuatro dígitos. Nunca devuelve PAN, CVV ni OTP.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/cards Credenciales Scope: cards.write Producto: virtual.cards

Crear tarjeta virtual

Emite una tarjeta solo cuando products y capabilities habilitan la acción. La emisión exige Idempotency-Key. La tarjeta prepaga en USD se financia desde la tesorería compartida del emisor abastecida en USDT; no debita ni convierte automáticamente la billetera Vexus Crypto del usuario final y no existe una operación atómica cripto a tarjeta. La White Label debe reservar y debitar su propio ledger de usuario por separado. El intervalo técnico actual es de USD 10.00 a USD 1000000.00. Cuando sea obligatorio, external_user_id en el body debe coincidir con X-Vexus-External-User-Id. No reintente una respuesta ambigua con una clave nueva.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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 DE EJEMPLO",
    "external_user_id": "witevexus:user:1001"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "product_code": "vexus_international",
    "amount": "10.00",
    "name_on_card": "CLIENTE DE EJEMPLO",
    "external_user_id": "witevexus:user:1001"
}
GET /api/v1/cards/{cardId} Credenciales Scope: cards.read Producto: virtual.cards

Consultar tarjeta

Sincroniza el saldo y el estado actuales de la tarjeta del usuario externo autenticado. Nunca devuelve PAN, CVV ni OTP.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/REEMPLAZA_CON_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());
DELETE /api/v1/cards/{cardId} Credenciales Scope: cards.write Producto: virtual.cards

Cancelar tarjeta

Cancela permanentemente una tarjeta solo mientras capabilities.actions.cancel=true. La acción puede devolver su saldo según las reglas de la tarjeta y exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
POST /api/v1/cards/{cardId}/fund Credenciales Scope: cards.write Producto: virtual.cards

Recargar tarjeta

Añade fondos prepagos en USD solo mientras capabilities.actions.fund=true. La recarga usa la tesorería compartida del emisor abastecida en USDT y no debita ni convierte automáticamente la billetera Vexus Crypto del usuario final. La White Label debe reservar y debitar su propio ledger por separado. Exige Idempotency-Key, acepta actualmente de USD 10.00 a USD 1000000.00 y devuelve las tarifas confirmadas.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{
    "amount": "10.00"
}
POST /api/v1/cards/{cardId}/freeze Credenciales Scope: cards.write Producto: virtual.cards

Congelar tarjeta

Congela temporalmente una tarjeta activa solo mientras capabilities.actions.freeze=true. Exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
POST /api/v1/cards/{cardId}/unfreeze Credenciales Scope: cards.write Producto: virtual.cards

Descongelar tarjeta

Reactiva una tarjeta congelada solo mientras capabilities.actions.unfreeze=true. Exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
GET /api/v1/cards/{cardId}/transactions Credenciales Scope: cards.read Producto: virtual.cards

Listar transacciones de la tarjeta

Devuelve un snapshot de transacciones y saldo para visualización y conciliación auxiliar. El contrato del emisor no define identificador estable, paginación, webhook ni correlación completa del ciclo de autorización, captura, reversión, reembolso y chargeback. No use esta respuesta como fuente contable. Nunca devuelve OTP, PAN ni CVV.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/REEMPLAZA_CON_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());
POST /api/v1/cards/{cardId}/display-sessions Credenciales Scope: cards.write Producto: virtual.cards

Crear visualización segura de la tarjeta

Crea una URL HTTPS de un solo uso, válida durante 120 segundos, que muestra PAN y CVV directamente en el navegador del usuario. Abra display_url directamente en un iframe cuyo origen coincida exactamente con allowed_origin; recargar o reutilizar falla. Nunca haga proxy, fetch, captura, persistencia ni log de la URL. Cuando sea obligatorio, X-Vexus-External-User-Id identifica al titular y external_user_id en el body, si se envía, debe coincidir. Recovery no vuelve a exponer display_url; tras la expiración cree otra sesión con una nueva Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{
    "allowed_origin": "https://witevexus.fun",
    "external_user_id": "witevexus:user:1001"
}
GET /api/v1/cards/webhooks Credenciales Scope: cards.read Producto: virtual.cards

Listar webhooks de OTP

Lista únicamente los endpoints de esta cuenta suscritos a virtual_card.otp.received. Nunca devuelve el secreto de firma.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/cards/webhooks Credenciales Scope: cards.write Producto: virtual.cards

Configurar webhook de OTP

Crea un endpoint HTTPS para virtual_card.otp.received, el único evento público de tarjeta virtual. signing_secret aparece únicamente en esta respuesta y debe permanecer en el almacén seguro del backend. Los eventos usan createdAt RFC 3339 UTC y HMAC sobre el body bruto. Exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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 de Producción",
    "url": "https://api.exemplo.com/webhooks/vexus"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "label": "OTP de Producción",
    "url": "https://api.exemplo.com/webhooks/vexus"
}
POST /api/v1/cards/webhooks/{webhookId}/rotate-secret Solo producción Credenciales Scope: cards.write Producto: virtual.cards PUBLISHED PRODUCTION ONLY

Rotar secreto del webhook OTP

Revoca inmediatamente el secreto anterior sin ventana de superposición y devuelve el nuevo signing_secret una sola vez. Coordine la actualización del receptor. Envíe un objeto JSON vacío e Idempotency-Key. Recovery nunca vuelve a exponer el secreto.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/webhooks/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
POST /api/v1/cards/webhooks/{webhookId}/activate Solo producción Credenciales Scope: cards.write Producto: virtual.cards PUBLISHED PRODUCTION ONLY

Activar webhook OTP

Reanuda las nuevas entregas de virtual_card.otp.received a un endpoint de la cuenta. Envíe un objeto JSON vacío e Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/webhooks/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
POST /api/v1/cards/webhooks/{webhookId}/deactivate Solo producción Credenciales Scope: cards.write Producto: virtual.cards PUBLISHED PRODUCTION ONLY

Desactivar webhook OTP

Pausa las nuevas entregas de virtual_card.otp.received sin eliminar el historial. Envíe un objeto JSON vacío e Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/cards/webhooks/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
Módulo

Cuenta

Consulta autorizada del saldo, límites financieros efectivos, tarifas y recuperación idempotente de operaciones.

GET /api/v1/account/limits Credenciales Scope: account.read Producto: account

Consultar límites de la cuenta

Devuelve los límites efectivos de la cuenta en BRL: agregado, entrada y salida PIX, boleto y transferencia interna. source indica si la regla procede de la política GLOBAL o de una personalización USER.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/account/fees Credenciales Scope: account.read Producto: account

Consultar tarifas de la cuenta

Devuelve las tarifas comerciales efectivas para PIX, boleto, tarjetas, tarjetas virtuales, transferencias internas y reglas por activo/red cripto. En cripto, la cotización de la operación es autoritativa para el costo de red, la tarifa de servicio, el importe neto y el débito total.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/account/operations/by-idempotency/{idempotencyKey} Solo producción Credenciales Scope: account.read Producto: DYNAMIC_FROM_ORIGINAL_OPERATION PUBLISHED PRODUCTION ONLY

Consultar operación por Idempotency-Key

Devuelve el estado sanitizado de la intención creada por la misma credencial de Producción. Exige account.read y valida dinámicamente el producto y los entitlements originales. Después de un timeout u OPERATION_STATUS_AMBIGUOUS, informe la operación y los headers de contexto originales. En cripto, una intención PENDING reciente sigue en curso; después de 60 segundos se promueve de forma conservadora a AMBIGUOUS con reconciliation_required=true. Deje de consultar esta ruta de recuperación al recibir ACCEPTED. wallet.create, withdrawal.quote, swap.quote, conversion.address y conversion.quote finalizan su propia intención con terminal=true; siga withdrawal.execute y swap.execute mediante el GET autoritativo de resource_id. Persista conversionId antes de confirmar una conversión porque la recuperación puede devolver ACCEPTED sin resource_id; luego consulte la conversión original. ACCEPTED nunca demuestra liquidación ni autoriza una nueva intención financiera. Recovery de display y webhook nunca vuelve a exponer display_url ni signing_secret. Un replay exacto del POST original conserva su respuesta durante 24 horas; un display expirado exige otra sesión y clave.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/account/operations/by-idempotency/REEMPLAZA_CON_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());
GET /api/v1/account/ted Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Consultar cuenta TED nominal

Devuelve la agencia, la cuenta, el dígito, la institución y el titular de la cuenta TED nominal del usuario autenticado sin exponer credenciales del proveedor.

Ejemplos de integración
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());
GET /api/v1/account/balance Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Consultar saldo de la cuenta nominal

Devuelve el saldo aislado en BRL de la cuenta nominal del usuario autenticado.

Ejemplos de integración
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());
GET /api/v1/account/transactions Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Listar transacciones de la cuenta nominal

Devuelve el extracto de la cuenta nominal para un intervalo de hasta 31 días con paginación y aislamiento por titular.

Ejemplos de integración
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());
GET /api/v1/nominal Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Consultar cuenta nominal

Devuelve la cuenta nominal activa y la clave PIX vinculada al usuario autenticado. Nunca expone credenciales del proveedor.

Ejemplos de integración
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());
GET /api/v1/nominal/ted Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Consultar agencia y cuenta nominal

Devuelve la agencia, la cuenta, el dígito y la institución de la cuenta nominal.

Ejemplos de integración
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());
GET /api/v1/nominal/balance Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Consultar saldo nominal

Devuelve el saldo en BRL de la cuenta nominal del usuario autenticado.

Ejemplos de integración
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());
GET /api/v1/nominal/transactions Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Listar transacciones nominales

Devuelve depósitos, transferencias salientes y otros movimientos de la cuenta nominal para un intervalo de hasta 31 días.

Ejemplos de integración
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());
GET /api/v1/nominal/pix-key Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Consultar clave PIX nominal

Devuelve la clave PIX nominal aprovisionada previamente.

Ejemplos de integración
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());
GET /api/v1/nominal/operations/{operationId} Solo producción Credenciales Scope: account.read Producto: account PUBLISHED PRODUCTION ONLY

Consultar operación nominal

Devuelve el resultado idempotente de una operación nominal de QR o salida PIX.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/nominal/operations/REEMPLAZA_CON_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());
POST /api/v1/balance Credenciales Scope: cashin Producto: pix.cash_in

Consultar saldo

Devuelve el saldo expuesto por el contrato de la cuenta. Envíe un objeto JSON vacío.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{}
Módulo

Conta nominal

POST /api/v1/nominal/pix-key Solo producción Credenciales Scope: pix.cash_in Producto: pix.cash_in PUBLISHED PRODUCTION ONLY

Crear clave PIX nominal

Solicita una cuenta virtual al proveedor bancario homologado con clave aleatoria, correo o CNPJ. Exige Idempotency-Key y una solicitud nominal aprobada administrativamente.

Exige Idempotency-Key.
Ejemplos de integración
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());
POST /api/v1/nominal/qr/dynamic Solo producción Credenciales Scope: pix.cash_in Producto: pix.cash_in PUBLISHED PRODUCTION ONLY

Crear QR dinámico nominal

Crea un cobro QR dinámico en la cuenta nominal. Exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
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());
POST /api/v1/nominal/qr/static Solo producción Credenciales Scope: pix.cash_in Producto: pix.cash_in PUBLISHED PRODUCTION ONLY

Crear QR estático nominal

Crea un QR estático en la cuenta nominal. Exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
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());
POST /api/v1/nominal/qr/decode Solo producción Credenciales Scope: pix.qr_pay Producto: pix.qr_pay PUBLISHED PRODUCTION ONLY

Decodificar QR nominal

Lee y valida un QR PIX mediante el proveedor bancario homologado sin ejecutar el pago.

Exige Idempotency-Key.
Ejemplos de integración
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());
POST /api/v1/nominal/qr/pay Solo producción Credenciales Scope: pix.qr_pay Producto: pix.qr_pay PUBLISHED PRODUCTION ONLY

Pagar QR nominal

Paga un QR PIX desde la cuenta nominal. El procesamiento es asíncrono y exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
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());
POST /api/v1/nominal/pix-out Solo producción Credenciales Scope: pix.cash_out Producto: pix.cash_out PUBLISHED PRODUCTION ONLY

Enviar PIX nominal

Envía PIX desde la cuenta nominal. La confirmación llega por webhook y la solicitud exige Idempotency-Key.

Exige Idempotency-Key.
Ejemplos de integración
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());
Módulo

White Label

Contrato White Label de la cuenta, incluidos plan, adicionales, tarifas, facturación y estado de acceso.

GET /api/v1/white-label Credenciales Scope: account.read Producto: white_label

Consultar contrato White Label

Devuelve en una respuesta el estado del contrato, el plan, los adicionales, la facturación, las tarifas y los productos habilitados. Este endpoint de consulta sigue disponible cuando la mensualidad está vencida.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/white-label/plan Credenciales Scope: account.read Producto: white_label

Consultar plan White Label

Devuelve el plan y los adicionales contratados por la cuenta autenticada.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/white-label/fees Credenciales Scope: account.read Producto: white_label

Consultar tarifas White Label

Devuelve las tarifas comerciales del plan, incluidas las de PIX, boleto, tarjeta virtual y las reglas por activo/red cripto.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/white-label/billing Credenciales Scope: account.read Producto: white_label

Consultar facturación White Label

Devuelve la mensualidad, la tarifa de alta, el importe pendiente, el vencimiento y el estado de acceso. No crea un cobro ni mueve fondos.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/white-label/status Credenciales Scope: account.read Producto: white_label

Consultar estado White Label

Devuelve únicamente el estado del contrato y si las operaciones financieras mediante la API están habilitadas.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
GET /api/v1/white-label/nominal Solo producción Credenciales Scope: account.read Producto: white_label

Listar solicitudes de cuenta nominal

Lista únicamente las solicitudes de la cuenta White Label. Los documentos aparecen enmascarados y los datos de identidad proceden del perfil central de VexusPay.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/white-label/nominal Solo producción Credenciales Scope: account.read Producto: white_label

Solicitar cuenta nominal

Envía una solicitud para análisis administrativo. No se aceptan nombre, CPF ni CNPJ en el body; VexusPay utiliza únicamente el KYC aprobado del titular.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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": "Cuenta operativa de mi marca para recibir pagos PIX."
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "reason": "Cuenta operativa de mi marca para recibir pagos PIX."
}
POST /api/v1/white-label/nominal/bind Solo producción Credenciales Scope: account.read Producto: white_label

Vincular cliente nominal

Vincula el identificador del cliente White Label a una cuenta nominal Vexus activa. El identificador se aísla por White Label.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
Ver corpo de exemplo 
{
    "nominal_user_id": 1001,
    "external_subject": "cliente:1001"
}
GET /api/v1/white-label/nominal/{requestId} Solo producción Credenciales Scope: account.read Producto: white_label

Consultar solicitud de cuenta nominal

Devuelve una solicitud de la cuenta White Label sin exponer el documento completo ni credenciales de la cuenta.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/white-label/nominal/REEMPLAZA_CON_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());
DELETE /api/v1/white-label/nominal/{requestId} Solo producción Credenciales Scope: account.read Producto: white_label

Cancelar solicitud de cuenta nominal

Cancela una solicitud que aún está pendiente o aprobada. Una cuenta ya aprovisionada no puede cancelarse mediante esta ruta.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/white-label/nominal/REEMPLAZA_CON_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());
Módulo

Soporte

Tickets y webhooks firmados para cualquier cuenta activa autenticada. Solo producción.

GET /api/v1/support/tickets Solo producción Credenciales Scope: support.manage Producto: support

Listar tickets de soporte

Solo producción. Lista hasta los 100 tickets actualizados más recientemente de la cuenta de la credencial. Nunca devuelve tickets de otras cuentas ni el contenido de sus mensajes.

Ejemplos de integración
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());
POST /api/v1/support/tickets Solo producción Credenciales Scope: support.manage Producto: support

Abrir ticket de soporte

Solo producción. Abre un ticket de la cuenta autenticada en la cola de soporte de VexusPay. Envíe texto, hasta cuatro attachment_ids cargados previamente, o ambos. Nunca incluya HTML, bytes/base64 ni credenciales en el body JSON.

Exige Idempotency-Key.
Ejemplos de integración
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": "Consulta sobre la integración PIX",
    "message": "Necesitamos validar cómo gestiona nuestra integración la respuesta asíncrona.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "category": "IMPLEMENTATION",
    "subject": "Consulta sobre la integración PIX",
    "message": "Necesitamos validar cómo gestiona nuestra integración la respuesta asíncrona.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}
GET /api/v1/support/tickets/{ticketId} Solo producción Credenciales Scope: support.manage Producto: support

Consultar ticket de soporte

Solo producción. Devuelve el ticket y la conversación cronológica únicamente cuando pertenecen a la cuenta de la credencial.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/support/tickets/REEMPLAZA_CON_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());
POST /api/v1/support/tickets/{ticketId}/messages Solo producción Credenciales Scope: support.manage Producto: support

Responder ticket de soporte

Solo producción. Añade texto, hasta cuatro attachment_ids cargados previamente, o ambos al ticket de la cuenta. Una respuesta devuelve el ticket a OPEN. Los tickets CLOSED no aceptan mensajes nuevos.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/tickets/REEMPLAZA_CON_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 el cambio y enviamos un nuevo correlation ID para su análisis.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "message": "Aplicamos el cambio y enviamos un nuevo correlation ID para su análisis.",
    "attachment_ids": [
        "d6c53708-95f6-46f2-8bf7-2c4cdd4ccade"
    ]
}
POST /api/v1/support/tickets/{ticketId}/close Solo producción Credenciales Scope: support.manage Producto: support

Cerrar ticket de soporte

Solo producción. Confirma el cierre del ticket de la cuenta. Envíe un objeto JSON vacío y conserve Idempotency-Key si necesita reintentar la solicitud.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/tickets/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
POST /api/v1/support/attachments Solo producción Credenciales Scope: support.manage Producto: support

Subir imagen de soporte

Solo producción. Acepta una imagen en el campo multipart file, verifica su MIME real, normaliza el bitmap y devuelve un attachment_id pendiente. Admite JPEG, PNG y WebP de hasta 5 MiB; un ID no vinculado expira después de 24 horas.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';
import { readFile } from 'node:fs/promises';

const idempotencyKey = crypto.randomUUID();

const image = await readFile('/ruta/a/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());
GET /api/v1/support/attachments/{attachmentId} Solo producción Credenciales Scope: support.manage Producto: support

Descargar imagen de soporte

Solo producción. Devuelve el binario privado de una imagen de la cuenta. Cada descarga exige credenciales API, usa Cache-Control: no-store y debe pasar por el backend de la integración. Nunca exponga el Client Secret al navegador.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/support/attachments/REEMPLAZA_CON_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);
GET /api/v1/support/webhooks Solo producción Credenciales Scope: support.manage Producto: support

Listar webhooks de soporte

Solo producción. Lista los endpoints de esta cuenta suscritos a eventos de soporte. Las URL se reducen a su origen HTTPS y nunca se devuelven los secretos de firma.

Ejemplos de integración
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());
POST /api/v1/support/webhooks Solo producción Credenciales Scope: support.manage Producto: support

Registrar webhook de soporte

Solo producción. Crea un endpoint HTTPS para eventos de soporte. signing_secret aparece únicamente en esta respuesta y debe guardarse inmediatamente en un almacén seguro. Si se omite events, se suscriben los cinco eventos de soporte.

Exige Idempotency-Key.
Ejemplos de integración
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": "Soporte de Producción",
    "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());
Ver corpo de exemplo 
{
    "label": "Soporte de Producción",
    "url": "https://api.exemplo.com/webhooks/vexus/support",
    "events": [
        "support.message.created",
        "support.ticket.status_changed",
        "support.ticket.closed"
    ]
}
POST /api/v1/support/webhooks/{webhookId}/rotate-secret Solo producción Credenciales Scope: support.manage Producto: support

Rotar secreto del webhook de soporte

Solo producción. Invalida el secreto anterior y devuelve el nuevo signing_secret una sola vez. Envíe un objeto JSON vacío y actualice el receptor antes de depender de nuevas entregas.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/webhooks/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
POST /api/v1/support/webhooks/{webhookId}/activate Solo producción Credenciales Scope: support.manage Producto: support

Activar webhook de soporte

Solo producción. Reactiva un endpoint de la cuenta y restablece su circuito de fallos. Envíe un objeto JSON vacío.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/webhooks/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
POST /api/v1/support/webhooks/{webhookId}/deactivate Solo producción Credenciales Scope: support.manage Producto: support

Desactivar webhook de soporte

Solo producción. Pausa nuevas entregas al endpoint sin eliminar su historial. Envíe un objeto JSON vacío.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/support/webhooks/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
Módulo

Split

Reglas, ejecución, consulta, cancelación, reembolsos e informes de Split Payment.

Flujo de la API de Split Payment VexusPay entre los receptores
GET /api/v1/splits/rules Credenciales Scope: split Producto: split

Listar reglas de split

Lista las reglas de split pertenecientes a la cuenta autenticada.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
POST /api/v1/splits/rules Credenciales Scope: split Producto: split

Crear regla de split

Crea una regla de split versionada mediante porcentajes o importes fijos.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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": "Socios",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "cuenta-socia",
            "percentage": "20.00"
        }
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "name": "Socios",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "cuenta-socia",
            "percentage": "20.00"
        }
    ]
}
PUT /api/v1/splits/rules/{ruleId} Credenciales Scope: split Producto: split

Revisar regla de split

Archiva la versión anterior de la regla y crea una versión nueva.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/splits/rules/REEMPLAZA_CON_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": "Socios v2",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "cuenta-socia",
            "percentage": "25.00"
        }
    ]
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "name": "Socios v2",
    "mode": "PERCENTAGE",
    "currency": "BRL",
    "participants": [
        {
            "handle": "cuenta-socia",
            "percentage": "25.00"
        }
    ]
}
DELETE /api/v1/splits/rules/{ruleId} Credenciales Scope: split Producto: split

Archivar regla de split

Archiva una regla de la cuenta. Esta operación no acepta body.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/splits/rules/REEMPLAZA_CON_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());
POST /api/v1/splits Credenciales Scope: split Producto: split

Crear split

Crea la operación financiera y las asignaciones a partir de una regla activa. La cuenta debe tener una ruta de liquidación Split homologada; la gestión de reglas sigue disponible sin ella.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/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 Ejemplo",
        "document": "52998224725",
        "email": "cliente@example.com"
    }
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "rule_id": "00000000-0000-4000-8000-000000000001",
    "amount": 100,
    "payer": {
        "name": "Cliente de Ejemplo",
        "document": "52998224725",
        "email": "cliente@example.com"
    }
}
GET /api/v1/splits/{splitId} Credenciales Scope: split Producto: split

Consultar split

Devuelve la operación y las asignaciones visibles para la cuenta propietaria.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/splits/REEMPLAZA_CON_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());
POST /api/v1/splits/{splitId}/cancel Credenciales Scope: split Producto: split

Cancelar split

Cancela un split únicamente cuando su estado financiero lo permite. No acepta body.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/api/v1/splits/REEMPLAZA_CON_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());
POST /api/v1/splits/{splitId}/refund Credenciales Scope: split Producto: split

Solicitar reembolso del split

Solicita un reembolso parcial o total. HTTP 202 indica procesamiento asíncrono, no finalización.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://api.nodexhub.com.br/api/v1/splits/REEMPLAZA_CON_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": "Reembolso parcial solicitado por el cliente"
}),
});

if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.json());
Ver corpo de exemplo 
{
    "amount": 25,
    "comment": "Reembolso parcial solicitado por el cliente"
}
GET /api/v1/splits/report Credenciales Scope: split Producto: split

Consultar informe de participante

Devuelve los elementos de la cuenta autenticada dentro del intervalo UTC informado.

Ejemplos de integración
const response = await fetch("https://api.nodexhub.com.br/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());
Módulo

Controles de Sandbox

Controles exclusivos de Sandbox para simular estados sin mover fondos reales.

GET /api/v1/sandbox/workspace Credenciales Scope: sandbox.manage

Consultar workspace Sandbox

Devuelve únicamente los saldos y recursos simulados de la cuenta autenticada.

Ejemplos de integración
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());
POST /api/v1/sandbox/faucet Credenciales Scope: sandbox.manage

Acreditar faucet de Sandbox

Acredita un activo simulado en el ledger aislado del Sandbox.

Exige Idempotency-Key.
Ejemplos de integración
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());
Ver corpo de exemplo 
{
    "asset": "USDT_BEP20",
    "amount": "25.00"
}
POST /api/v1/sandbox/reset Credenciales Scope: sandbox.manage

Restablecer workspace Sandbox

Elimina únicamente los recursos Sandbox de esta cuenta y recrea su saldo simulado inicial.

Exige Idempotency-Key.
Ejemplos de integración
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());
Ver corpo de exemplo 
{
    "confirmation": "RESET_SANDBOX"
}
POST /api/v1/sandbox/resources/{resourceType}/{resourceId}/actions Credenciales Scope: sandbox.manage

Cambiar estado de recurso Sandbox

Aprueba, falla, expira o revierte una operación simulada pendiente.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/resources/REEMPLAZA_CON_RESOURCE_TYPE/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{
    "action": "APPROVE"
}
POST /api/v1/sandbox/crypto/deposits Credenciales Scope: sandbox.manage

Simular depósito cripto

Crea un depósito simulado sin transmisión ni consulta blockchain. Use el wallet_id devuelto al crear o listar una billetera Sandbox de la misma cuenta.

Exige Idempotency-Key.
Ejemplos de integración
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());
Ver corpo de exemplo 
{
    "wallet_id": "00000000-0000-4000-8000-000000000003",
    "amount": "10.00",
    "confirmations": 0
}
POST /api/v1/sandbox/cards/{cardId}/transactions Credenciales Scope: sandbox.manage

Simular transacción de tarjeta

Simula la aprobación, el rechazo, la reversión o el reembolso de una tarjeta simulada.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/cards/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{
    "amount": "12.50",
    "currency": "USD",
    "outcome": "APPROVED"
}
POST /api/v1/sandbox/cards/{cardId}/otp Credenciales Scope: sandbox.manage

Generar OTP de billetera digital

Genera un OTP simulado y lo entrega únicamente mediante el pipeline de webhooks Sandbox.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/cards/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{
    "wallet_type": "GOOGLE_PAY"
}
GET /api/v1/sandbox/webhook-deliveries Credenciales Scope: sandbox.manage

Listar entregas de webhook

Lista las entregas y los intentos de webhook del entorno Sandbox.

Ejemplos de integración
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());
POST /api/v1/sandbox/webhook-deliveries/{deliveryId}/retry Credenciales Scope: sandbox.manage

Reintentar webhook de Sandbox

Vuelve a programar una entrega Sandbox sin afectar los webhooks de producción.

Exige Idempotency-Key.
Ejemplos de integración
import crypto from 'node:crypto';

const idempotencyKey = crypto.randomUUID();

const response = await fetch("https://sandbox-api.example.invalid/api/v1/sandbox/webhook-deliveries/REEMPLAZA_CON_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());
Ver corpo de exemplo 
{}
Transparencia

Disponibilidad

Entrada, salida y código QR PIX PUBLISHED
Emisión, consulta y pago de boleto PUBLISHED
Vexus Cripto — catálogo, billeteras y depósitosNão existe webhook público de ciclo de vida cripto; consulte o recurso até estado terminal. PUBLISHED
Vexus Cripto — retirosCotización, ejecución idempotente y seguimiento hasta un estado terminal. PUBLISHED
Vexus Cripto — swapsSame-chain BSC/TRON y cross-chain USDT únicamente para los pares publicados. PUBLISHED
Vexus Cripto — transferencias internasLiquidación únicamente en ledger; no crea TXID. PUBLISHED
Cripto — BRL a criptoExige destino externo, capacidad habilitada y cotización válida. Los activos y redes proceden del catálogo y de capabilities. PUBLISHED WITH EXPLICIT AUTHORIZATION
Cripto — cripto a BRLLas ventas nuevas siguen bloqueadas hasta publicar el contrato completo de recepción y liquidación. No envíe cotizaciones ni confirmaciones en esta dirección. MAINTENANCE
Sandbox públicoDNS, TLS y health checks públicos validados. No utiliza saldos, credenciales, proveedores ni webhooks de Producción. AVAILABLE
Reglas, creación, consulta, cancelación, reembolso e informe de split PUBLISHED
Recuperación de operación por Idempotency-KeyLa misma credencial consulta operation + Idempotency-Key después de un timeout o una respuesta ambigua sin repetir el movimiento financiero. PUBLISHED PRODUCTION ONLY
VexusPay CardsExige producto virtual.cards, permisos cards.read/cards.write y entitlement virtual.card.api. No expone PAN ni CVV. El OTP se entrega únicamente por el webhook firmado virtual_card.otp.received. PUBLISHED WITH EXPLICIT AUTHORIZATION
Pago tradicional con tarjeta (card.pay)Cobro independiente sin artículo del catálogo de Checkout. Exige producto card y acepta únicamente un token de un solo uso creado por el SDK configurado, nunca PAN ni CVV. PUBLISHED PRODUCTION ONLY
API de gestión de CheckoutProductos, enlaces, medios habilitados e informes exigen producto checkout y scope checkout. PUBLISHED
API de contrato White LabelConsulta plan, adicionales, tarifas, facturación y estado. Las consultas siguen disponibles en OVERDUE o SUSPENDED; las APIs operativas devuelven WHITE_LABEL_OVERDUE o WHITE_LABEL_SUSPENDED. PUBLISHED WITH EXPLICIT AUTHORIZATION
Tickets de soporte, imágenes adjuntas y webhooksDisponible para cuentas activas con producto support y scope support.manage. Las imágenes privadas usan upload multipart y descarga autenticada separados y nunca aparecen como bytes/base64 en webhooks. PUBLISHED PRODUCTION ONLY
Webhooks del clienteEventos publicados: checkout.order.status_changed, financial.operation.status_changed, virtual_card.otp.received y los cinco eventos support.*. PUBLISHED
API pública MED/disputasLas disputas se gestionan mediante el panel y soporte. No debe inferirse ninguna ruta pública. NOT PUBLISHED