Xendit API Node.js Client

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

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
Installation
Usage
Contributing

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;
  isRecurring?: boolean;
})

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: '[email protected]',
  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: '[email protected]',
  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;
  updateScheduledCycle?: boolean;
  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;
  updateScheduledCycle?: boolean;
  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;
  searchType?: CycleDashboardSearchType;
  searchValue?: 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: '[email protected]',
}).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: '[email protected]',
  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;
  apiVersion?: string;
  referenceID: string;
  paymentMethodID: string;
  currency: string;
  amount: number;
  callbackURL: string;
  enableOTP?: boolean;
  description?: string;
  basket?: Basket[];
  device?: object;
  metadata?: object;
  successRedirectUrl?: string;
  failureRedirectUrl?: string;
});

Validate OTP for direct debit payment

dd.validateOTPforPayment(data: {
  directDebitID: string;
  otpCode: string;
  apiVersion?: 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: '[email protected]',
  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;
  }>;
})

Payment Request

Instanitiate Payment Request using constructor that has been injected with Xendit keys

const { PaymentRequest } = x;
const r = new PaymentRequest();

Example: Create a Payment Request

r.createPaymentRequest({
      amount: 1500,
      currency: 'PHP',
      payment_method: {
        type: 'EWALLET',
        ewallet: {
          channel_code: 'GRABPAY',
          channel_properties: {
            success_return_url: 'https://redirect.me/goodstuff',
            failure_return_url: 'https://redirect.me/badstuff',
          },
        },
        reusability: 'ONE_TIME_USE',
      }
}).then(({ id }) => {
  console.log(`payment request created with ID: ${id}`);
});

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

Create payment request

r.createPaymentRequest(data: {
    currency: PaymentRequestCurrencies;
    amount: number;
    reference_id?: string;
    customer_id?: string;
    country: PaymentRequestCountries;
    description?: string;
    payment_method: object;
    channel_properties?: PaymentRequestChannelProperties;
    metadata?: object;
    idempotency_key?: string;
    for_user_id?: string;
})

List payment requests

r.listpaymentrequests(data: {
    id?: string;
    reference_id?: string;
    customer_id?: string;
    type?: PaymentRequestType;
    channel_code?: string;
    status?: PaymentRequestStatuses;
    limit?: number;
    after_id?: string;
    before_id?: string;
    for_user_id?: string;
})

Get payment request details by ID

r.getPaymentRequestByID(data: {
    id: string;
    for_user_id?: string;
})

confirm payment request

r.confirmPaymentRequest(data: {
    id: string;
    auth_code: string;
    idempotency_key?: string;
    for_user_id?: string;
})

resend auth for payment request

r.resendAuthForPaymentRequest(data: {
    id: string;
    idempotency_key?: string;
    for_user_id?: string;
})

Payment Method

Instanitiate Payment Method using constructor that has been injected with Xendit keys

const { PaymentMethod } = x;
const r = new PaymentMethod();

Example: Create a Payment Method

r.createPaymentMethod({
      type: 'DIRECT_DEBIT',
      reusability: 'ONE_TIME_USE',
      customer_id: '16f72571-9b3a-43dc-b241-5b71f470202f',
      country: 'ID',
      direct_debit: {
        channel_code: 'BRI',
        channel_properties: {
          mobile_number: '+6281299640904',
          card_last_four: '8888',
          card_expiry: '10/29',
          email: '[email protected]',
        },
      },
}).then(({ id }) => {
  console.log(`payment method created with ID: ${id}`);
});

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

Create payment method

r.createPaymentMethodV2(data: {
  type: PaymentMethodV2Types;
  reusability: PaymentMenthodV2Reusabilities;
  reference_id?: string;
  customer_id?: string;
  country?: CreatePaymentMenthodV2Countries;
  description?: string;
  billing_information?: BillingInformationItems;
  metadata?: object;
  ewallet?: EwalletItems;
  direct_debit?: DirectDebitItems;
  card?: CardItems;
  over_the_counter?: OverTheCounterItems;
  virtual_account?: VirtualAccountItems;
  qr_code?: QRISItems;
  for_user_id?: string;
  idempotency_key?: string;
})

List payment methods

r.listPaymentMethodV2(data: {
  payment_method_id?: string;
  payment_method_type?: string;
  channel_code?: string;
  limit?: number;
  after_id?: string;
  before_id?: string;
  for_user_id?: string;
})

Get payment method details by ID

r.getPaymentMethodByIdV2(data: {
    id: string;
    for_user_id?: string;
})

Authorize Payment method

r.authorizePaymentMethodV2(data: {
    id: string;
    auth_code: string;
    for_user_id?: string;
    idempotency_key?: string;
})

Update Payment method

r.updatePaymentMethodV2(data: {
    id: string;
    reference_id?: string;
    description?: string;
    metadata?: object;
    status?: object;
    reusability?: PaymentMenthodV2Reusabilities;
    over_the_counter?: UpdateOverTheCounterItems;
    virtual_account?: UpdateVirtualAccountItems;
    for_user_id?: string;
})

Expire Payment method

r.expirePaymentMethodV2(data: {
    id: string;
    for_user_id?: string;
    idempotency_key?: string;
})

List payments by payment method id

r.listPaymentsByPaymentMethodIdV2(data: {
    id: string;
    payment_request_id?: string;
    reference_id?: string;
    status?: ListPaymentMethodV2StatusItems;
    limit?: number;
    after_id?: string;
    before_id?: string;
    created?: string;
    updated?: string;
    for_user_id?: string;
})

Refund Services

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

const { Refund } = x;
const r = new Refund();

Example: Create a refund

r.createRefund({
      invoice_id: 'your-invoice-id',
      reason: 'FRAUDULENT',
      amount: 1000,
}).then(({ id }) => {
  console.log(`refund created with ID: ${id}`);
});

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

Create refund

r.createRefund(data: {
  payment_request_id?: string;
  reference_id?: string;
  invoice_id?: string;
  currency?: string;
  amount?: number;
  reason: RefundReasons;
  metadata?: object;
  idempotency_key?: string;
  for_user_id?: string;
})

List refunds

r.listRefunds(data: {
  payment_request_id?: string;
  invoice_id?: string;
  payment_method_type?: string;
  channel_code?: string;
  limit?: number;
  after_id?: string;
  before_id?: string;
  for_user_id?: string;
})

Get refund details by ID

r.getRefundById(data: {
  id: 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.

okabrionz / xendit-node Goto Github PK

xendit-node's Introduction

Xendit API Node.js Client

API Documentation

Installation

Usage

Card Services

Create charge

Capture charge

Get charge

Create authorization

Reverse authorization

Create refund

Create promotion

Virtual Account Services

Get banks with available virtual account service

Create a fixed virtual account

Get details of your fixed virtual account

Update details of your fixed virtual account

Get details of a VA payment

Disbursement Services

Get banks with available disbursement service

Create a disbursement

Create a batch of disbursements

Get a disbursement by ID

Invoice Services

Create an invoice

Get an invoice

Expire an invoice

Get all invoices

Recurring Payments Services

Create recurring payment

Get recurring payment

Edit recurring payment

Stop recurring payment

Pause recurring payment

Resume recurring payment

Recurring Services

Create recurring schedule

Edit recurring schedule

Get recurring schedule

Create recurring plan

Create recurring plan with schedule

Edit recurring plan

Get recurring plan

Deactivate recurring plan

Edit recurring cycle

Get recurring cycle

Get all recurring cycles

Cancel recurring cycle

Payout Services

Create a payout

Get a payout

Void a payout

EWallet Services

Create payment

Get payment

Create an ewallet charge

Get an ewallet charge status

Void an ewallet charge

Initialize tokenization

Unlink tokenization

Create payment method (E-Wallet)

Get payment methods by customer ID (E-Wallet)

Balance Services

Get balance

Retail Outlet Services

Create fixed payment code

Get fixed payment code

Get payments by fixed payment code ID

Update fixed payment code

Simulate payment for RO (only in dev mode)

QR Code Services

Create code

Get code

Simulate payment for QR (only in dev mode)

Get payments by external ID

Customer services

Create customer

Get customer