ChannelApe SDK

TypeScript and JavaScript SDK for the ChannelApe REST API

Features

• Getting Started
• Errors
• Sessions
• Actions
• Channels
• Suppliers
• Orders
• Variants
• Businesses
  • API Accounts
• Subscriptions
• Order Activities
• Analytics
• Product Filters
• Users
• Inventories
  • Inventory Quantities
• Locations
• Steps
• Plays
• Batches
  • Batch Inventory Adjustments

Getting Started

The ChannelApe SDK is asynchronous and all functions return promises.

Creating a client

Create a new instance of the ChannelApeClient with your sessionId.

const channelApeClient = new ChannelApeClient({
  sessionId: '4674b668-c4d2-4270-bf9b-ebaab78c378d'
});

Optional client configurations

• timeout – Number of milliseconds to wait for the API to send response headers. Defaults to 180000 (3 minutes). Cannot be set lower than 2000 (2 seconds).
• endpoint – Environment endpoint you would like to hit. Defaults to https://api.channelape.com
• logLevel – Level of logs you wish to see from the SDK. Defaults to OFF.
• maximumRequestRetryTimeout – Number of milliseconds to keep retrying a request for when an undesired response status code is received. Defaults to 180000 (3 minutes). Cannot be set lower than 2000 (2 seconds).
• minimumRequestRetryRandomDelay – Minimum number of milliseconds to randomly delay by when an undesired response status code is received. Defaults to 1000 (1 second). Cannot be set lower than 1000 (1 second).
• maximumRequestRetryRandomDelay – Maximum number of milliseconds to randomly delay by when an undesired response status code is received. Defaults to 5000 (5 seconds). Cannot be set lower than 2000 (2 seconds).
• maximumConcurrentConnections – Maximum number of connections or requests that can be made to the API at a single time. Defaults to 5.

Error Handling

When a call to the ChannelApe API returns an error, it can be accessed through the ApiErrors array on the error object. The following is an example:

try {
  newOrder = await client.orders().create(orderWithChannelOrderIdThatAlreadyExists);
} catch (error) {
  if (error?.ApiErrors?.code === 168) {
    ... Handle duplicate channel order ID error
  }
}

Error codes and descriptions can be found here: Postman API Error Handling

Sessions

Get Session

A User Account session will include your userId which is useful when retrieving Businesses. API Account sessions will return an apiAccountId instead.

channelApeClient.sessions().get(sessionId)
  .then((session: Session) => {
    // do what you need to do with session data here
    // session will also include your userId or apiAccountId
  });

Actions

Get action

channelapeClient.actions().get(actionId)
  .then((action: Action) => {
    // do what you need to do with action data here
  });

Complete action

channelapeClient.actions().complete(actionId)
  .then((action: Action) => {
    // do what you need to do with action data here
  });

Update action with error

channelapeClient.actions().error(actionId)
  .then((action: Action) => {
    // do what you need to do with action data here
  });

Update action health check

channelapeClient.actions().updateHealthCheck(actionId)
  .then((action: Action) => {
    // do what you need to do with action data here
  });

Channels

Get channel

channelapeClient.channels().get(channelId)
  .then((channel: Channel) => {
    // do what you need to do with channel data here
  });

Get all channels for a business

channelapeClient.channels().get({ businessId: 'some-valid-business-id' })
  .then((channels: Channel[]) => {
    // do what you need to do with channel data here
  });

Create a channels for a business

channelapeClient.channels().create({
      additionalFields: [],
      integrationId: 'some-valid-integration-id',
      name: 'channel-name',
      credentials: {
        healthCheckInterval: 300,
        payloadUrl: 'channelape.com'
      },
      businessId: 'some-valid-business-id',
      enabled: true
    })
  .then((channels: Channel) => {
    // do what you need to do with channel data here
  });

Update a channels for a business

channelapeClient.channels().update({
      additionalFields: [],
      id: 'valid-channel-id'
      integrationId: 'some-valid-integration-id',
      name: 'channel-name',
      credentials: {
        healthCheckInterval: 300,
        payloadUrl: 'channelape.com'
      },
      businessId: 'some-valid-business-id',
      enabled: true
    })
  .then((channels: Channel) => {
    // do what you need to do with channel data here
  });

Suppliers

Get supplier

channelapeClient.suppliers().get(supplierId)
  .then((supplier: Supplier) => {
    // do what you need to do with supplier data here
  });

Get all suppliers for a business

channelapeClient.suppliers().get({ businessId: 'some-valid-business-id' })
  .then((suppliers: Supplier[]) => {
    // do what you need to do with supplier data here
  });

Update a supplier

channelapeClient.suppliers().update(supplierUpdateRequest)
  .then((supplier: Supplier) => {
    // do what you need to do with supplier data here
  });

Create a supplier

channelapeClient.suppliers().create(SupplierCreateRequest)
  .then((supplier: Supplier) => {
    // do what you need to do with supplier data here
  });

Orders

Get order

channelapeClient.orders().get(orderId)
  .then((order: Order) => {
    // do what you need to do with order data here
  });

Update order

channelapeClient.orders().update(order)
  .then((updatedOrder: Order) => {
    // do what you need to do with updatedOrder data here
  });

Patch order

channelapeClient.orders().patch(order)
  .then((patchedOrder: Order) => {
    // do what you need to do with patchedOrder data here
  });

Create order

const orderToCreate: OrderCreateRequest = {
  additionalFields: [
    { name: 'name', value: 'CA1001' },
    { name: 'order_number', value: '1001' }
  ],
  totalPrice: 295.99,
  alphabeticCurrencyCode: 'USD',
  channelId: 'your-channel-id',
  channelOrderId: 'specify-your-channel-order-id',
  customer: {
    firstName: 'John',
    lastName: 'Smith',
    name: 'John Smith',
    additionalFields: [
      { name: 'extraCustomerData', value: 'Put whatever you would like here' }
    ]
  },
  status: OrderStatus.OPEN,
  purchasedAt: new Date(),
  lineItems: [{
    id: 'some-line-item-id',
    quantity: 1,
    sku: 'NCC1701D',
    title: 'A model space ship',
    additionalFields: [
      { name: 'extraLineItemData', value: 'Put whatever you would like here' }
    ]
  }]
};
channelapeClient.orders().create(orderCreateRequest)
  .then((createdOrder: Order) => {
    // do what you need to do with the createdOrder data here
  });

Variants

Get Variant

const variantsRequest: VariantsRequest = {
  productId,
  inventoryItemValue
};
channelApeClient.variants().get(variantsRequest)
  .then((variant: Variant) => {
    // do what you need to do with variant data here
  });

Get Variants for a Product

const variantsRequestByProductId: VariantsRequestByProductId = {
  productId
};
channelApeClient.variants().get(variantsRequestByProductId)
  .then((variants: Variant[]) => {
    // do what you need to do with variant array
  })

Get Variant Search Results for a Vendor

const variantsRequest: VariantsSearchRequestByVendor = {
  vendor,
  businessId
};
channelApeClient.variants().search(variantsRequest)
  .then((variantSearchResults: VariantSearchResults[]) => {
    // do what you need to do with Variant Search Results array
  });

Get Variant Search Results using a Product Filter

const variantsRequest: VariantsSearchRequestByProductFilterId = {
  productFilterId
};
channelApeClient.variants().search(variantsRequest)
  .then((variantSearchResults: VariantSearchResults[]) => {
    // do what you need to do with Variant Search Results array
  });

Get Variant Search Results for a SKU

• exactMatch parameter if set to true will only match the exact sku set on the request instead of all sku’s that start with that given character sequence.

const variantsRequest: VariantsSearchRequestBySku = {
  sku,
  businessId,
  exactMatch: true
};
channelApeClient.variants().search(variantsRequest)
  .then((variantSearchResults: VariantSearchResults[]) => {
    // do what you need to do with Variant Search Results array
  });

Get Variant Search Results for a UPC

• exactMatch parameter if set to true will only match the exact upc set on the request instead of all upc’s that start with that given character sequence.

const variantsRequest: VariantsSearchRequestByUpc = {
  upc,
  businessId,
  exactMatch: true
};
channelApeClient.variants().search(variantsRequest)
  .then((variantSearchResults: VariantSearchResults[]) => {
    // do what you need to do with Variant Search Results array
  });

Get Variant Search Results for a Tag

const variantsRequest: VariantsSearchRequestByTag = {
  tag,
  businessId
};
channelApeClient.variants().search(variantsRequest)
  .then((variantSearchResults: VariantSearchResults[]) => {
    // do what you need to do with Variant Search Results array
  });

Businesses

Get Business

const businessesQueryRequestByBusinessId: BusinessesQueryRequestByBusinessId = {
  businessId
}
channelApeClient.businesses().get(businessesQueryRequestByBusinessId)
  .then((business: Business) => {
    // do what you need to do with business data here
  });

Get Businesses

const businessesQueryRequestByUserId: BusinessesQueryRequestByUserId = {
  userId
}
channelApeClient.businesses().get(businessesQueryRequestByUserId)
  .then((businesses: Business[]) => {
    // do what you need to do with businesses array data here
  });

See Sessions for how to retrieve your userId

Get Business Member

const businessMemberRequest: BusinessMemberRequest = {
  userId,
  businessId
}
channelApeClient.businesses().getBusinessMember(businessMemberQueryRequest)
  .then((businessMember: BusinessMember) => {
    // do what you need to do with the business member here
  });

Get Business Members

const businessMemberRequest: BusinessMemberRequest = {
  userId,
  businessId
}
channelApeClient.businesses().getBusinessUsers(businessId)
  .then((users: User[]) => {
    // do what you need to do with the business members here
  });

Invite a Member to a business

const businessId = 'valid-business-id';
const email = 'valid-email-id';
channelApeClient.businesses().inviteMember(email, businessId)
then((invitationMember: InvitationResponse) => {
    // send invitationMember to a user
  });

Remove a Member from a business

const businessId = 'valid-business-id';
const userId = 'valid-id';
channelApeClient.businesses().removeMember(businessId, userId)
then((removedMember: BusinessMember) => {
    // remove a member from business
  });

Update a Business’s Settings

const businessToUpdate: Business = {
  name: 'name',
  inventoryItemKey: InventoryItemKey.SKU,
  timeZone: TimeZoneId.US_ALASKA,
  alphabeticCurrencyCode: AlphabeticCurrencyCode.USD,
  id: 'valid-id',
  embeds: [],
  errors: []
}
channelApeClient.businesses().update(businessToUpdate)
  .then((updatedBusiness: Business) => {
    // do what you need to do with the updated business here 
  });

Verify Business Member

const verificationCode = '1234567';
channelApeClient.businesses().verifyBusinessMember(verificationCode)
  .then((business: Business) => {
    // do what you need to do with the business here
  });

Create Business

const businessToCreate: BusinessCreateRequest = {
  name: 'Valid Business Name',
  timeZone: TimeZoneId.AMERICA_NEW_YORK,
  inventoryItemKey: InventoryItemKey.SKU,
  alphabeticCurrencyCode: AlphabeticCurrencyCode.USD
}
channelApeClient.businesses().create(businessToCreate)
  .then((business: Business) => {
    // do what you need to do with the newly created business here 
  });

API Accounts

Get API Account By ID

const businessId = 'valid-business-id';
const apiAccountId = 'valid-api-account-id';
channelApeClient.businesses().apiAccounts().get(businessId, apiAccountId)
  .then((apiAccount: ApiAccount) => {
    // do what you need to do with the API account here 
  });

Get All API Accounts for a Business

const businessId =...