eGiftly Vendor API

const response = await fetch('https://vendor.e-giftly.com/api/login', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'egiftly-client-id': 'YOUR_CLIENT_ID'
  },
  body: JSON.stringify({
    email: 'vendor@example.com',
    password: 'your_password'
  })
});

const data = await response.json();
const token = data.data.access_token;
localStorage.setItem('token', token);

$ch = curl_init('https://vendor.e-giftly.com/api/login');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'email' => 'vendor@example.com',
    'password' => 'your_password'
]));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'egiftly-client-id: YOUR_CLIENT_ID'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);
$token = $data['data']['access_token'];

$response = Http::withHeaders([
    'egiftly-client-id' => env('EGIFTLY_CLIENT_ID')
])->post('https://vendor.e-giftly.com/api/login', [
    'email' => 'vendor@example.com',
    'password' => 'your_password'
]);

$token = $response->json('data.access_token');

{
  "code": 2002,
  "message": "email or password are missing from your payload, please check your payload and try again",
  "status": "error",
  "data": []
}

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch('https://vendor.e-giftly.com/api/wallet/balance', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${token}`,
    'egiftly-client-id': clientId
  }
});

const data = await response.json();
console.log(`Balance: ${data.data.balance}`);

$ch = curl_init('https://vendor.e-giftly.com/api/wallet/balance');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $token,
    'egiftly-client-id: ' . $clientId
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);
$balance = $data['data']['balance'];

$response = Http::withToken($token)
    ->withHeaders([
        'egiftly-client-id' => env('EGIFTLY_CLIENT_ID')
    ])
    ->get('https://vendor.e-giftly.com/api/wallet/balance');

$balance = $response->json('data.balance');

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch(
  'https://vendor.e-giftly.com/api/wallet/transactions',
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch('https://vendor.e-giftly.com/api/brands?per_page=20', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${token}`,
    'egiftly-client-id': clientId
  }
});

const data = await response.json();
data.data.data.forEach(brand => {
  console.log(`${brand.brand_name} - ${brand.category_name}`);
});

$ch = curl_init('https://vendor.e-giftly.com/api/brands');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $token,
    'egiftly-client-id: ' . $clientId
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);

foreach ($data['data']['data'] as $brand) {
    echo $brand['brand_name'] . "\n";
}

$response = Http::withToken($token)
    ->withHeaders([
        'egiftly-client-id' => env('EGIFTLY_CLIENT_ID')
    ])
    ->get('https://vendor.e-giftly.com/api/brands', [
        'per_page' => 20,
        'page' => 1
    ]);

$brands = $response->json('data.data');

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch(
  'https://vendor.e-giftly.com/api/denominations/list?brandId=1',
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
data.data.data.forEach(d => {
  console.log(`${d.denominationName} - $${d.price}`);
});

$ch = curl_init('https://vendor.e-giftly.com/api/denominations/list?brandId=1');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $token,
    'egiftly-client-id: ' . $clientId
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);

foreach ($data['data']['data'] as $denom) {
    echo $denom['denominationName'] . "\n";
}

$response = Http::withToken($token)
    ->withHeaders([
        'egiftly-client-id' => env('EGIFTLY_CLIENT_ID')
    ])
    ->get('https://vendor.e-giftly.com/api/denominations/list', [
        'brandId' => 1,
        'per_page' => 20
    ]);

$denominations = $response->json('data.data');

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const denomId = 101;
const response = await fetch(
  `https://vendor.e-giftly.com/api/denominations/${denomId}`,
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
console.log(`Price: $${data.data.price}`);

{
  "code": 0,
  "message": "This denomination is not exist in our database, please check the denomination ID and try again",
  "status": "success",
  "data": []
}

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch(
  'https://vendor.e-giftly.com/api/order/list',
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
console.log(`Total Orders: ${data.data.total}`);

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch('https://vendor.e-giftly.com/api/order/create', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'egiftly-client-id': clientId,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    uniqueOrderId: 'CUST-ORD-001',
    denominationId: 101,
    quantity: 2
  })
});

const data = await response.json();
if (data.status === 'success') {
  console.log(`Order ID: ${data.data.orderId}`);
  console.log(`Codes:`, data.data.code);
}

$ch = curl_init('https://vendor.e-giftly.com/api/order/create');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'uniqueOrderId' => 'CUST-ORD-001',
    'denominationId' => 101,
    'quantity' => 2
]));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $token,
    'egiftly-client-id: ' . $clientId,
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);
if ($data['status'] === 'success') {
    $orderId = $data['data']['orderId'];
}

$response = Http::withToken($token)
    ->withHeaders([
        'egiftly-client-id' => env('EGIFTLY_CLIENT_ID')
    ])
    ->post('https://vendor.e-giftly.com/api/order/create', [
        'uniqueOrderId' => 'CUST-ORD-001',
        'denominationId' => 101,
        'quantity' => 2
    ]);

if ($response->json('status') === 'success') {
    $orderId = $response->json('data.orderId');
    $codes = $response->json('data.code');
}

{
  "code": 3007,
  "message": "Your wallet does not have enough balance to make this purchase",
  "status": "error",
  "data": []
}

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const orderId = 5432;
const response = await fetch(
  `https://vendor.e-giftly.com/api/order/codes/${orderId}`,
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
data.data.codes.forEach(code => {
  console.log(`Code: ${code.code}`);
});

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch(
  'https://vendor.e-giftly.com/api/topups/denominations?brandId=12',
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
data.data.items.forEach(item => {
  console.log(`${item.brand.name} - ${item.name} - $${item.price}`);
});

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const denomId = 301;
const response = await fetch(
  `https://vendor.e-giftly.com/api/topups/denominations/${denomId}/config`,
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
data.data.fields.forEach(f => console.log(f.key, f.label, f.type));

{
  "code": 6002,
  "message": "This top-up denomination does not exist or is not available",
  "status": "error",
  "data": []
}

{
  "code": 6006,
  "message": "This top-up denomination is not currently fulfillable, please try again later",
  "status": "error",
  "data": []
}

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch('https://vendor.e-giftly.com/api/topups', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'egiftly-client-id': clientId,
    'Content-Type': 'application/json',
    'Idempotency-Key': crypto.randomUUID()
  },
  body: JSON.stringify({
    denomination_id: 301,
    customer_reference: 'CUST-TOPUP-001',
    parameters: {
      playerId: '5123456789',
      serverId: 'Asia'
    }
  })
});

const data = await response.json();
if (data.status === 'success') {
  console.log(`Topup ID: ${data.data.id}, status: ${data.data.status}`);
}

$ch = curl_init('https://vendor.e-giftly.com/api/topups');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'denomination_id' => 301,
    'customer_reference' => 'CUST-TOPUP-001',
    'parameters' => [
        'playerId' => '5123456789',
        'serverId' => 'Asia'
    ]
]));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $token,
    'egiftly-client-id: ' . $clientId,
    'Content-Type: application/json',
    'Idempotency-Key: ' . \Illuminate\Support\Str::uuid()
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);
if ($data['status'] === 'success') {
    $topupId = $data['data']['id'];
}

$response = Http::withToken($token)
    ->withHeaders([
        'egiftly-client-id' => env('EGIFTLY_CLIENT_ID'),
        'Idempotency-Key' => (string) Str::uuid()
    ])
    ->post('https://vendor.e-giftly.com/api/topups', [
        'denomination_id' => 301,
        'customer_reference' => 'CUST-TOPUP-001',
        'parameters' => [
            'playerId' => '5123456789',
            'serverId' => 'Asia'
        ]
    ]);

if ($response->json('status') === 'success') {
    $topupId = $response->json('data.id');
    $status = $response->json('data.status');
}

{
  "code": 6005,
  "message": "Your wallet does not have enough balance to make this purchase",
  "status": "error",
  "data": []
}

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const topupId = 9001;
const response = await fetch(
  `https://vendor.e-giftly.com/api/topups/${topupId}/status`,
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
console.log(`Status: ${data.data.status}`);

{
  "code": 6010,
  "message": "This top-up order does not exist",
  "status": "error",
  "data": []
}

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch(
  'https://vendor.e-giftly.com/api/range-denominations/list?brandId=103',
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
data.data.forEach(item => {
  console.log(`${item.name} - ${item.minAmount}-${item.maxAmount} ${item.currency} @ ${item.unitPrice}/unit`);
});

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const code = 'RD-1MUZNII9';
const response = await fetch(
  `https://vendor.e-giftly.com/api/range-denominations/${code}`,
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
console.log(`${data.data.minAmount}-${data.data.maxAmount} ${data.data.currency}`);

{
  "code": 6002,
  "message": "This range denomination does not exist",
  "status": "error",
  "data": []
}

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const response = await fetch('https://vendor.e-giftly.com/api/range-orders/create', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'egiftly-client-id': clientId,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    uniqueOrderId: 'CUST-RANGE-001',
    code: 'RD-1MUZNII9',
    amount: 10
  })
});

const data = await response.json();
if (data.status === 'success') {
  console.log(`Order ID: ${data.data.orderId}, status: ${data.data.status}`);
}

$ch = curl_init('https://vendor.e-giftly.com/api/range-orders/create');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'uniqueOrderId' => 'CUST-RANGE-001',
    'code' => 'RD-1MUZNII9',
    'amount' => 10
]));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $token,
    'egiftly-client-id: ' . $clientId,
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);
if ($data['status'] === 'success') {
    $orderId = $data['data']['orderId'];
}

$response = Http::withToken($token)
    ->withHeaders(['egiftly-client-id' => env('EGIFTLY_CLIENT_ID')])
    ->post('https://vendor.e-giftly.com/api/range-orders/create', [
        'uniqueOrderId' => 'CUST-RANGE-001',
        'code' => 'RD-1MUZNII9',
        'amount' => 10
    ]);

if ($response->json('status') === 'success') {
    $orderId = $response->json('data.orderId');
    $status = $response->json('data.status');
}

{
  "code": 6004,
  "message": "Amount must be at most 500.0000",
  "status": "error",
  "data": []
}

const token = localStorage.getItem('token');
const clientId = 'YOUR_CLIENT_ID';
const orderId = 'RG-20260909162409HU56';
const response = await fetch(
  `https://vendor.e-giftly.com/api/range-orders/${orderId}/status`,
  {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${token}`,
      'egiftly-client-id': clientId
    }
  }
);

const data = await response.json();
console.log(`Status: ${data.data.status}`);

{
  "code": 0,
  "message": "Order status fetched successfully",
  "status": "success",
  "data": {
    "orderId": "RG-20260909162409HU56",
    "uniqueOrderId": "CUST-RANGE-001",
    "status": "processing",
    "requestedAmount": 10,
    "price": 10.40,
    "currency": "USD",
    "createdAt": "2026-09-09T16:24:09.000000Z",
    "code": null
  }
}

{
  "code": 6010,
  "message": "This order does not exist",
  "status": "error",
  "data": []
}

{
  "event": "order.code.refunded",
  "eventReference": 9813,
  "orderId": 5432,
  "vendorOrderUniqueId": "CUST-ORD-001",
  "refund": {
    "brandName": "Amazon",
    "brandId": 1,
    "denominationId": 101,
    "denominationName": "$50",
    "refundedAmount": 48.75,
    "orderFullyRefunded": false
  },
  "pendingCodesRemaining": 0,
  "date": "2026-07-23T14:20:00.000000Z",
  "signature": "b64EncodedSignatureString=="
}

$payload = json_decode($request->getContent(), true);

$signature = $payload['signature'];
unset($payload['signature']);

// decrypt the signature back into the original JSON string
$decrypted = openssl_decrypt(
    base64_decode($signature),   // undo the outer base64 layer
    'AES-256-CBC',
    $yourPublicKey,
    0,                           // options = 0, openssl expects base64 input
    $yourSecretKey
);

if ($decrypted === json_encode($payload)) {
    // signature valid, process the event
    http_response_code(200);
}

{
  "event": "topup.failed",
  "eventReference": 15202,
  "topupOrderId": 9002,
  "vendorOrderUniqueId": "CUST-TOPUP-002",
  "denominationId": 301,
  "status": "failed",
  "price": 10.49,
  "currency": "USD",
  "failureReason": "The top-up request could not be completed.",
  "completedAt": null,
  "date": "2026-08-20T14:22:10.000000Z",
  "signature": "b64EncodedSignatureString=="
}

{
  "event": "topup.processing",
  "eventReference": 15200,
  "topupOrderId": 9001,
  "vendorOrderUniqueId": "CUST-TOPUP-001",
  "denominationId": 301,
  "status": "processing",
  "price": 10.49,
  "currency": "USD",
  "failureReason": null,
  "completedAt": null,
  "date": "2026-08-20T14:20:05.000000Z",
  "signature": "b64EncodedSignatureString=="
}

{
  "event": "order.code.refunded",
  "eventReference": "RG-20260909162409HU56",
  "orderId": "RG-20260909162409HU56",
  "vendorOrderUniqueId": "CUST-RANGE-001",
  "refund": {
    "brandName": "Binance",
    "brandId": 103,
    "denominationName": "Binance 1 - 500 USDT Open Amount",
    "denominationCode": "RD-1MUZNII9",
    "refundedAmount": 10.40,
    "orderFullyRefunded": true
  },
  "pendingCodesRemaining": 0,
  "date": "2026-09-09T16:24:45.000000Z",
  "signature": "b64EncodedSignatureString=="
}