Skip to content
master
Switch branches/tags
Code

README.md

Xendit API Node.js Client

Code Linting Badge Integration Tests Badge Coverage Status

This library is the abstraction of Xendit API for access from applications written with server-side Javascript.

NPM

Note: This library is only meant for usage from server-side with Xendit secret API key. For PCI compliance to be maintained, tokenization of credit cards info should be done on client side with Xendit.js.

API Documentation

Please check Xendit API Reference.

Installation

npm install --save xendit-node

Usage

Configure package with your account's secret key obtained from your Xendit Dashboard.

const Xendit = require('xendit-node');
const x = new Xendit({
  secretKey: 'xnd_...',
});

Usage examples:

  • With promises, please check here
  • With async/await, please check here

Card Services

Instanitiate Card service using constructor that has been injected with Xendit keys

const { Card } = x;
const cardSpecificOptions = {};
const card = new Card(cardSpecificOptions);

Example: Capturing a charge

card
  .captureCharge({
    chargeID: 'charge-id-from-create-charge-endpoint',
    externalID: 'your-system-tracking-id',
  })
  .then(({ id }) => {
    console.log(`Charge created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`Charge creation failed with message: ${e.message}`);
  });

Refer to Xendit API Reference for more info about methods' parameters

Create charge

card.createCharge(data: {
  tokenID: string;
  externalID: string;
  amount?: number;
  authID?: string;
  cardCVN?: string;
  capture?: boolean;
  descriptor?: string;
  currency?: string;
  midLabel?: string;
  billingDetails?: object;
  promotion?: object;
  installment?: object;
  forUserID?: string;
  metadata?: object;
})

Capture charge

card.captureCharge(data: {
  chargeID: string;
  amount: number;
  forUserID?: string;
})

Get charge

card.getCharge(data: { chargeID: string; forUserID?: string })

Create authorization

card.createAuthorization(data: {
  tokenID: string;
  externalID: string;
  amount?: number;
  authID?: string;
  cardCVN?: string;
  descriptor?: string;
  currency?: string;
  midLabel?: string;
  billingDetails?: object;
  promotion?: object;
  installment?: object;
  forUserID?: string;
})

Reverse authorization

card.reverseAuthorization(data: {
  chargeID: string;
  externalID: string;
  forUserID?: string;
})

Create refund

card.createRefund(data: {
  chargeID: string;
  amount: number;
  externalID: string;
  xIdempotencyKey?: string;
  forUserID?: string;
})

Create promotion

card.createPromotion(data: {
  referenceId: string;
  description: string;
  promoCode?: string;
  binList?: string[];
  channelCode?: string;
  discountPercent?: number;
  discountAmount?: number;
  currency: string;
  startTime: Date;
  endTime: Date;
  minOriginalAmount?: number;
  maxDiscountAmount?: number;
})

Virtual Account Services

Instanitiate VA service using constructor that has been injected with Xendit keys

const { VirtualAcc } = x;
const vaSpecificOptions = {};
const va = new VirtualAcc(vaSpecificOptions);

Example: Create a fixed virtual account

va.createFixedVA({
  externalID: 'your-external-id',
  bankCode: 'BCA',
  name: 'Stanley Nguyen',
})
  .then(({ id }) => {
    console.log(`Fixed VA created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`VA creation failed with message: ${e.message}`);
  });

Refer to Xendit API Reference for more info about methods' parameters

Get banks with available virtual account service

va.getVABanks(data?: {
  forUserID?: string;
});

Create a fixed virtual account

va.createFixedVA(data: {
  externalID: string;
  bankCode: string;
  name: string;
  virtualAccNumber?: string;
  suggestedAmt?: number;
  isClosed?: boolean;
  expectedAmt?: number;
  expirationDate?: Date;
  isSingleUse?: boolean;
  description?: string;
  forUserID?: string;
})

Get details of your fixed virtual account

va.getFixedVA(data: {
  id: string;
  forUserID?: string;
})

Update details of your fixed virtual account

va.updateFixedVA(data: {
  id: string;
  suggestedAmt?: number;
  expectedAmt?: number;
  expirationDate?: Date;
  isSingleUse?: boolean;
  description?: string;
  forUserID?: string;
})

Get details of a VA payment

va.getVAPayment(data: {
  paymentID: string;
  forUserID?: string;
})

paymentID: ID of the payment that you obtained from your callback

Disbursement Services

Instanitiate Disbursement service using constructor that has been injected with Xendit keys

const { Disbursement } = x;
const disbursementSpecificOptions = {};
const d = new Disbursement(disbursementSpecificOptions);

Example: Create a disbursement

d.create({
  externalID: 'your-external-tracking-ID',
  bankCode: 'BCA',
  accountHolderName: 'Stan',
  accountNumber: '1234567890',
  description: 'Payment for nasi padang',
  amount: 10000,
})
  .then(({ id }) => {
    console.log(`Disbursement created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`Disbursement creation failed with message: ${e.message}`);
  });

Refer to Xendit API Reference for more info about methods' parameters

Get banks with available disbursement service

d.getBanks();

Create a disbursement

d.create(data: {
  externalID: string;
  bankCode: string;
  accountHolderName: string;
  accountNumber: string;
  description: string;
  amount: number;
  emailTo?: string[];
  emailCC?: string[];
  emailBCC?: string[];
  xIdempotencyKey?: string;
  forUserID?: string;
  withFeeRule?: string;
})

Create a batch of disbursements

d.createBatch(data: {
  reference: string;
  disbursements: Array<{
    externalID: string;
    bankCode: string;
    accountHolderName: string;
    accountNumber: string;
    description: string;
    amount: number;
    emailTo?: string[];
    emailCC?: string[];
    emailBCC?: string[];
    forUserID?: string;
    withFeeRule?: string;
  }>;
  xIdempotencyKey?: string;
})

Get a disbursement by ID

d.getByID(data: { disbursementID: string })
  • Get a disbursement by external ID
d.getByExtID(data: { externalID: string })

Invoice Services

Instanitiate Invoice service using constructor that has been injected with Xendit keys

const { Invoice } = x;
const invoiceSpecificOptions = {};
const i = new Invoice(invoiceSpecificOptions);

Example: Create an invoice

i.createInvoice({
  externalID: 'your-external-id',
  payerEmail: 'stanley@xendit.co',
  description: 'Invoice for Shoes Purchase',
  amount: 100000,
}).then(({ id }) => {
  console.log(`Invoice created with ID: ${id}`);
});

Refer to Xendit API Reference for more info about methods' parameters

Create an invoice

i.createInvoice(data: {
  externalID: string;
  payerEmail: string;
  description: string;
  amount: number;
  shouldSendEmail?: boolean;
  callbackVirtualAccountID?: string;
  invoiceDuration?: number;
  successRedirectURL?: string;
  failureRedirectURL?: string;
  paymentMethods?: string[];
  currency?: string;
  midLabel?: string;
  forUserID?: string;
})

Get an invoice

i.getInvoice(data: { invoiceID: string; forUserID?: string })

Expire an invoice

i.expireInvoice(data: {
  invoiceID: string;
  forUserID?: string;
})

Get all invoices

i.getAllInvoices(data?: {
  statuses?: string[];
  limit?: number;
  createdAfter?: Date;
  createdBefore?: Date;
  paidAfter?: Date;
  paidBefore?: Date;
  expiredAfter?: Date;
  expiredBefore?: Date;
  lastInvoiceID?: string;
  clientTypes?: string[];
  paymentChannels?: string[];
  onDemandLink?: string;
  recurringPaymentID?: string;
  forUserID?: string;
})

Recurring Payments Services

Instanitiate Recurring Payments service using constructor that has been injected with Xendit keys

const { RecurringPayment } = x;
const rpSpecificOptions = {};
const rp = new RecurringPayment(rpSpecificOptions);

Example: Create a recurring payment

rp.createPayment({
  externalID: '123',
  payerEmail: 'stanley@xendit.co',
  description: 'Payment for something',
  amount: 10000,
  interval: RecurringPayment.Interval.Month,
  intervalCount: 1,
})
  .then(({ id }) => {
    console.log(`Recurring payment created with ID: ${id}`);
  })
  .catch(e => {
    console.error(
      `Recurring payment creation failed with message: ${e.message}`,
    );
  });

Refer to Xendit API Reference for more info about methods' parameters

Create recurring payment

rp.createPayment(data: {
  externalID: string;
  payerEmail?: string;
  description?: string;
  amount: number;
  interval: Interval;
  intervalCount: number;
  totalRecurrence?: number;
  invoiceDuration?: number;
  shouldSendEmail?: boolean;
  missedPaymentAction?: Action;
  creditCardToken?: string;
  startDate?: Date;
  successRedirectURL?: string;
  failureRedirectURL?: string;
  recharge?: boolean;
  chargeImmediately?: boolean;
  currency?: string;
  rescheduleAt?: Date;
  customer?: object;
  customerNotificationPreference?: object;
  reminderTimeUnit?: string;
  reminderTime?: number;
  paymentMethodId?: string;
})

Get recurring payment

rp.getPayment(data: { id: string })

Edit recurring payment

rp.editPayment(data: {
  id: string;
  amount?: number;
  creditCardToken?: string;
  interval?: Interval;
  intervalCount?: number;
  shouldSendEmail?: boolean;
  invoiceDuration?: number;
  missedPaymentAction?: Action;
  rescheduleAt?: Date;
  customerId?: string;
  reminderTimeUnit?: string;
  reminderTime?: number;
  paymentMethodId?: string;
})

Stop recurring payment

rp.stopPayment(data: { id: string })

Pause recurring payment

rp.pausePayment(data: { id: string })

Resume recurring payment

rp.resumePayment(data: { id: string })

Recurring Services

Instantiate Recurring service using constructor that has been injected with Xendit keys

const { Recurring } = x;
const rSpecificOptions = {};
const r = new Recurring(rSpecificOptions);

Example: Create a recurring plan

r.createPlan({
  businessId: '6066ebf68204c740b61aa3c6',
  referenceId: 'ref-123',
  customerId: 'cus-123',
  recurringAction: 'PAYMENT',
  currency: 'IDR',
  amount: 1000,
  paymentMethods: [
    { paymentMethodId: 'pm-123', rank: 1 },
  ],
  scheduleId: 'resc-123',
  immediateActionType: 'FULL_AMOUNT',
  notificationConfig: {
    recurringCreated: ['EMAIL'],
    recurringSucceeded: ['SMS'],
    recurringFailed: ['WHATSAPP']
  },
  failedCycleAction: 'RESUME'
})
  .then(({ id }) => {
    console.log(`Recurring plan created with ID: ${id}`);
  })
  .catch(e => {
    console.error(
      `Recurring plan creation failed with message: ${e.message}`,
    );
  });

Refer to Xendit API Reference for more info about methods' parameters

Create recurring schedule

r.createSchedule(data: {
  referenceId: string;
  businessId: string;
  interval: string;
  intervalCount: number;
  totalRecurrence?: number;
  anchorDate?: string;
  retryInterval?: string;
  retryIntervalCount?: number;
  totalRetry?: number;
  failedAttemptNotifications?: number[];
});

Edit recurring schedule

r.editSchedule(data: {
  id: string;
  businessId: string;
  interval: string;
  intervalCount: number;
  totalRecurrence?: number;
  anchorDate?: string;
  retryInterval?: string;
  retryIntervalCount?: number;
  totalRetry?: number;
  failedAttemptNotifications?: number[];
});

Get recurring schedule

r.getSchedule(data: {
  id: string;
  businessId: string;
});

Create recurring plan

r.createPlan(data: {
  businessId: string;
  referenceId: string;
  customerId: string;
  recurringAction: RecurringAction;
  currency: Currency;
  amount: number;
  paymentMethods?: Array<PaymentMethodIdRanked>;
  scheduleId: string;
  immediateActionType?: ImmediateActionType | null;
  notificationConfig?: NotificationConfig | null;
  failedCycleAction?: FailingCycleAction;
  metadata?: object | null;
})

Create recurring plan with schedule

r.createPlan(data: {
  businessId: string;
  referenceId: string;
  customerId: string;
  recurringAction: RecurringAction;
  currency: Currency;
  amount: number;
  paymentMethods?: Array<PaymentMethodIdRanked>;
  schedule: RecurringSchedule;
  immediateActionType?: ImmediateActionType | null;
  notificationConfig?: NotificationConfig | null;
  failedCycleAction?: FailingCycleAction;
  metadata?: object | null;
})

Edit recurring plan

r.editPlan(data: {
  businessId: string;
  customerId?: string;
  currency?: Currency;
  amount?: number;
  paymentMethods?: Array<PaymentMethodIdRanked>;
  notificationConfig?: NotificationConfig | null;
  metadata?: object | null;
  description?: string;
})

Get recurring plan

r.getPlan(data: { id: string; businessId: string; })

Deactivate recurring plan

r.deactivatePlan(data: { id: string; businessId: string; })

Edit recurring cycle

r.editCycle(data: {
  id: string;
  businessId: string;
  planId: string;
  scheduledTimestamp: string;
  currency: Currency;
  amount: number;
  metadata?: object | null;
})

Get recurring cycle

r.getCycle(data: {
  id: string;
  planId: string;
  businessId: string;
})

Get all recurring cycles

r.getAllCycles(data: {
  planId: string;
  businessId: string;
  limit?: number;
  beforeId?: string;
  afterId?: string;
})

Cancel recurring cycle

r.cancelCycle(data: {
  id: string;
  planId: string;
  businessId: string;
})

Payout Services

Instantiate Payout service using constructor that has been injected with Xendit keys

const { Payout } = x;
const payoutSpecificOptions = {};
const p = new Payout(payoutSpecificOptions);

Example: Create a payout

p.createPayout({
  externalID: 'your-external-id',
  amount: 100000,
  email: 'stanley@xendit.co',
}).then(({ id }) => {
  console.log(`Invoice created with ID: ${id}`);
});

Refer to Xendit API Reference for more info about methods' parameters

Create a payout

p.createPayout(data: {
  externalID: string;
  amount: string;
  email: string;
})

Get a payout

p.getPayout(data: { id: string })

Void a payout

p.voidPayout(data: { id: string })

EWallet Services

Instanitiate EWallet service using constructor that has been injected with Xendit keys

const { EWallet } = x;
const ewalletSpecificOptions = {};
const ew = new EWallet(ewalletSpecificOptions);

Example: Create an ewallet charge

ew.createEWalletCharge({
  referenceID: 'test-reference-id',
  currency: 'IDR',
  amount: 50000,
  checkoutMethod: 'ONE_TIME_PAYMENT',
  channelCode: 'ID_OVO',
  channelProperties: {
    mobileNumber: '+6281234567890',
  },
}).then(r => {
  console.log('created ewallet payment charge:', r);
  return r;
});

Refer to Xendit API Reference for more info about methods' parameters

Create payment

ew.createPayment(data: {
  externalID: string;
  amount: number;
  phone?: string;
  expirationDate?: Date;
  callbackURL?: string;
  redirectURL?: string;
  items?: PaymentItem[];
  ewalletType: CreateSupportWalletTypes;
  xApiVersion?: string;
})

Get payment

ew.getPayment(data: {
  externalID: string;
  ewalletType: GetSupportWalletTypes;
})

Create an ewallet charge

ew.createEWalletCharge(data: {
  referenceID: string;
  currency: Currency;
  amount: number;
  checkoutMethod: string;
  channelCode?: ChannelCode;
  channelProperties?: ChannelProps;
  paymentMethodId?: string;
  customerID?: string;
  basket?: Basket[];
  metadata?: object;
  forUserID?: string;
  withFeeRule?: string;
})

Get an ewallet charge status

ew.getEWalletChargeStatus(data: {
  chargeID: string;
  forUserID?: string;
})

Void an ewallet charge

ew.voidEWalletCharge(data: {
  chargeID: string;
  forUserID?: string;
})

Initialize tokenization

ew.initializeTokenization(data: {
  customerID: string;
  channelCode: ChannelCode;
  properties?: OnlineBankingAccessProperties;
  metadata?: object;
})

Unlink tokenization

ew.unlinkTokenization(data: {
  linkedAccTokenID: string;
})

Create payment method (E-Wallet)

ew.createPaymentMethod(data: {
  customerID: string;
  type: PaymentMethodType;
  properties: PaymentMethodProperties;
  metadata?: object;
})

Get payment methods by customer ID (E-Wallet)

ew.getPaymentMethodsByCustomerID(data: {
    customerID: string;
})

Balance Services

Instanitiate Balance service using constructor that has been injected with Xendit keys

const { Balance } = x;
const balanceSpecificOptions = {};
const i = new Balance(balanceSpecificOptions);

Example: Get balance of holding account

b.getBalance({
  accountType: Balance.AccountType.Holding,
}).then(({ balance }) => {
  console.log('Holding balance amount:', balance);
});

Refer to Xendit API Reference for more info about methods' parameters

Get balance

b.getBalance(data: {
  accountType: AccountType;
  forUserID?: string;
})

Retail Outlet Services

Instanitiate Retail outlet service using constructor that has been injected with Xendit keys

const { RetailOutlet } = x;
const retailOutletSpecificOptions = {};
const ro = new RetailOutlet(retailOutletSpecificOptions);

Example: Example: Create a fixed payment code

ro.createFixedPaymentCode({
  externalID: '123',
  retailOutletName: 'ALFAMART',
  name: 'Ervan Adetya',
  expectedAmt: 10000,
}).then(({ id }) => {
  console.log(`Fixed Payment Code created with ID: ${id}`);
});

Refer to Xendit API Reference for more info about methods' parameters

Create fixed payment code

ro.createFixedPaymentCode(data: {
  externalID: string;
  retailOutletName: string;
  name: string;
  expectedAmt: number;
  paymentCode?: string;
  expirationDate?: Date;
  isSingleUse?: boolean;
})

Get fixed payment code

ro.getFixedPaymentCode(data: { id: string })

Get payments by fixed payment code ID

ro.getPaymentsByFixedPaymentCodeId(data: { id: string })

Update fixed payment code

ro.updateFixedPaymentCode(data: {
  id: string
  name?: string;
  expectedAmt?: number;
  expirationDate?: Date;
})

Simulate payment for RO (only in dev mode)

ro.simulatePayment(data: {
  retailOutletName: string;
  paymentCode: string;
  transferAmount: number;
})

QR Code Services

Instanitiate QR Code service using constructor that has been injected with Xendit keys

const { QrCode } = x;
const qrcodeSpecificOptions = {};
const q = new QrCode(qrcodeSpecificOptions);

Example: create a QR code

q.createCode({
  externalID: 'your-system-tracking-id',
  amount: 10000,
  type: QrCode.Type.Dynamic,
  callback_url: 'https://yourwebsite/callback',
})
  .then(({ id }) => {
    console.log(`QR code created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`QR code creation failed with message: ${e.message}`);
  });

Refer to Xendit API Reference for more info about methods' parameters

Create code

q.createCode(data: {
  externalID: string;
  type: QrCodeTypes;
  callbackURL: string;
  amount?: number;
});

Get code

q.getCode(data: { externalID: string });

Simulate payment for QR (only in dev mode)

q.simulate(data: { externalID: string; amount?: number });

Get payments by external ID

q.getPayments(data: {
  externalID: string;
  from?: string;
  to?: string;
  limit?: number;
});

Customer services

Instanitiate customer service using constructor that has been injected with Xendit keys

const { Customer } = x;
const customerSpecificOptions = {};
const c = new Customer(customerSpecificOptions);

Example: create a customer

c.createCustomer({
  referenceID: 'ref-id-example-1',
  givenNames: 'customer 1',
  email: 'customer@website.com',
  mobileNumber: '+6281212345678',
  description: 'dummy customer',
  middleName: 'middle',
  surname: 'surname',
  addresses: [],
})
  .then(({ id }) => {
    console.log(`Customer created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`Customer creation failed with message: ${e.message}`);
  });

Refer to Xendit API Reference for more info about methods' parameters

Create customer

c.createCustomer(data: {
  referenceID: string;
  mobileNumber?: string;
  email?: string;
  givenNames: string;
  middleName?: string;
  surname?: string;
  description?: string;
  phoneNumber?: string;
  nationality?: string;
  addresses?: Address[];
  dateOfBirth?: string;
  metadata?: object;
});

Get customer

c.getCustomer(data: { id: string });

Get customer by reference ID

c.getCustomerByReferenceID(data: { referenceID: string });

Update customer

c.updateCustomer(data: {
  id: string;
  referenceID?: string;
  givenNames?: string;
  mobileNumber?: string;
  addresses?: Address[];
  description?: string;
  middleName?: string;
  surname?: string;
  phoneNumber?: string;
  nationality?: string;
  dateOfBirth?: string;
  metadata?: object;
  })

Direct debit services

Instanitiate direct debit service using constructor that has been injected with Xendit keys

const { DirectDebit } = x;
const directDebitSpecificOptions = {};
const dd = new DirectDebit(directDebitSpecificOptions);

Example: create a direct debit payment

dd.createDirectDebitPayment({
  idempotencyKey: '7960e3fd-9a1d-469d-8b3e-2f88df139c50',
  referenceID: 'merchant-ref-id-ex-1',
  paymentMethodID: 'pm-8c09656d-09fe-4bdd-bd8d-87495a71d231',
  currency: 'IDR',
  amount: 15000,
  callbackURL: 'https://payment-callback-listener/',
  enableOTP: true,
})
  .then(({ id }) => {
    console.log(`Direct debit payment created with ID: ${id}`);
  })
  .catch(e => {
    console.error(`Direct debit creation failed with message: ${e.message}`);
  });

Refer to Xendit API Reference for more info about methods' parameters

Initialize linked account tokenization

dd.initializeTokenization(data: {
  customerID: string;
  channelCode: ChannelCode;
  properties?: DebitCardProperties | OnlineBankingAccessProperties;
  device?: object;
  metadata?: object;
});

Validate OTP for Linked Account Token

dd.validateOTPforLinkedAccount(data: {
  tokenID: string;
  otpCode: string;
});

Retrieve accessible accounts by linked account token

dd.retrieveAccountsByTokenID(data: {
  tokenID: string;
});

Create payment method (Direct Debit)

dd.createPaymentMethod(data: {
  customerID: string;
  type: PaymentMethodType;
  properties: PaymentMethodProperties;
  metadata?: object;
});

Get payment methods by customer ID (Direct Debit)

dd.getPaymentMethodsByCustomerID(data: {
  customerID: string;
});

Create direct debit payment

dd.createDirectDebitPayment(data: {
  idempotencyKey: string;
  referenceID: string;
  paymentMethodID: string;
  currency: string;
  amount: number;
  callbackURL: string;
  enableOTP?: boolean;
  description?: string;
  basket?: Basket[];
  device?: object;
  metadata?: object;
});

Validate OTP for direct debit payment

dd.validateOTPforPayment(data: {
  directDebitID: string;
  otpCode: string;
})

Get direct debit payment status by ID

dd.getDirectDebitPaymentStatusByID(data: {
  directDebitID: string;
});

Get direct debit payment status by reference ID

dd.getDirectDebitPaymentStatusByReferenceID(data: {
  referenceID: string;

Report Service

Instantiate the Report service using a constructor which has been injected with Xendit keys.

const { Report } = x;
const reportSpecificOptions = {};
const r = new Report(reportSpecificOptions);

Example: Generating a report

r.generateReport({
  type: 'BALANCE_HISTORY',
  filterDateFrom: new Date(new Date().getTime() - 24 * 60 * 60 * 1000), // Yesterday's Date
  filterDateTo: new Date(),
  format: 'CSV',
  currency: 'IDR',
})
  .then(res => {
    console.log('Generated report:', res);
  })
  .catch(e => {
    console.error(`Generate Report Failed with Error: ${e.message}`);
  });

Generate Report

r.generateReport(data: {
  type: reportTypes;
  filterDateFrom?: Date;
  filterDateTo?: Date;
  format?: formatTypes;
  currency?: currencyTypes;
})

Get Report

r.getReport(data: {
  id: string
})

Transaction Service

Instantiate the Transaction service using a constructor which has been injected with Xendit keys.

const { Transaction } = x;
const transactionSpecificOptions = {};
const t = new Transaction(transactionSpecificOptions);

Example: Getting a transaction

t.getTransaction({
  id: 'txn_123',
})
  .then(res => {
    console.log('Get Transaction:', res);
  })
  .catch(e => {
    console.error(`Get Transaction Failed with Error: ${e.message}`);
  });

Get Transaction

t.getTransaction(data: {
  id: string;
})

List Transactions

t.listTransactions(data: {
  types?: Array<string>;
  statuses?: Array<string>;
  channelCategories?: Array<string>;
  referenceId?: string;
  productId?: string;
  accountIdentifier?: string;
  currency?: string;
  amount?: number;
  limit?: number;
  afterId?: string;
  beforeId?: string;
  createdDateFrom?: Date;
  createdDateTo?: Date;
  updatedDateFrom?: Date;
  updatedDateTo?: Date;
})

XenPlatform Service

Instanitiate Platform service using constructor that has been injected with Xendit keys

const { Platform } = x;
const platformSpecificOptions = {};
const p = new Platform(platformSpecificOptions);

Example: Creating a sub-account

p.createAccount({
  accountEmail: 'example@gmail.com',
  type: 'MANAGED',
})
  .then(({ user_id }) => {
    console.log(`Account created with ID: ${user_id}`);
  })
  .catch(e => {
    console.error(`Account creation failed with message: ${e.message}`);
  });

Refer to Xendit API Reference for more info about methods' parameters

Create sub-account

p.createAccount(data: {
  accountEmail: string;
  type: AccountTypes;
  businessProfile?: {
    businessName: string;
  };
})

Create sub-account using V2

p.createV2Account(data: {
  email: string;
  type: string;
  publicProfile?: {
    businessName: string;
  };
})

Get sub-account by ID

p.getAccountByID(data: {
  id: string;
})

Update sub-account

p.updateAccount(data: {
  id: string;
  email: string;
  publicProfile?: {
    businessName: string;
  };
})

Set Callback URL

p.setCallbackURL(data: {
  type: string;
  url: string;
  forUserID?: string;
})

Create transfers

p.createTransfer(data: {
  reference: string;
  amount: number;
  sourceUserID: string;
  destinationUserID: string;
})

Create fee rules

p.createFeeRule(data: {
  name: string;
  description?: string;
  routes: Array<{
    unit: string;
    amount: number;
    currency: string;
  }>;
})

Contributing

Running test suite

npm install
npm run test

Running examples

cp .env.sample .env # then fill in required environment variables
node examples/card.js # or whichever example you would like to run

There are a commit hook to run linting and formatting and push hook to run all tests. Please make sure they pass before making commits/pushes.

For any requests, bug or comments, please open an issue or submit a pull request.