JavaScript SDK

<script src="//cdn.split.io/sdk/split-10.22.5.min.js"></script>

npm install --save @splitsoftware/splitio@10.22.5

bower install splitio=https://cdn.split.io/sdk/split-10.22.5.min.js

// Instantiate the SDK. CDN will expose splitio globally 
var factory = splitio({ 
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    // key represents your internal user id, or the account id that 
    // the user belongs to. 
    // This could also be a cookie you generate for anonymous users
    key: 'key'
  }
});

// And get the client instance you'll use
var client = factory.client();

var SplitFactory = require('@splitsoftware/splitio').SplitFactory;

// Instantiate the SDK
var factory = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    // key represents your internal user id, or the account id that 
    // the user belongs to. 
    // This could also be a cookie you generate for anonymous users
    key: 'key'
  }
});

// And get the client instance you'll use
var client = factory.client();

// Use the import let = require syntax on TS.
import { SplitFactory } from '@splitsoftware/splitio';

// Instantiate the SDK
const factory: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    // the key can be the logged in
    // user id, or the account id that 
    // the logged in user belongs to. 
    // The type of customer (user, account, custom)
    // is chosen during Split's sign-up process.
    key: 'key'
  },
  startup: {
    readyTimeout: 1.5 // 1.5 sec
  }
});

// And get the client instance you'll use
const client: SplitIO.IClient = factory.client();

client.on(client.Event.SDK_READY, function() {
  var treatment = client.getTreatment('FEATURE_FLAG_NAME');

  if (treatment == "on") {
      // insert code here to show on treatment
  } else if (treatment == "off") {
      // insert code here to show off treatment
  } else {
      // insert your control treatment code here
  }
});

client.on(client.Event.SDK_READY, function() {
  const treatment: SplitIO.Treatment = client.getTreatment('FEATURE_FLAG_NAME');

  if (treatment == "on") {
      // insert code here to show on treatment
  } else if (treatment == "off") {
      // insert code here to show off treatment
  } else {
      // insert your control treatment code here
  }
});

// You can just destroy and remove the variable reference and move on:
user_client.destroy();
user_client = null;

// destroy() returns a promise, so if you want to, for example,
// navigate to another page without losing impressions, you 
// can do that once the promise resolves.
user_client.destroy().then(function() {
  user_client = null;

  document.location.replace('another_page');
});

var featureFlagNames = ['FEATURE_FLAG_NAME_1', 'FEATURE_FLAG_NAME_2'];

var treatments = client.getTreatments(featureFlagNames);

// treatments will have the following form: 
// {
//   FEATURE_FLAG_NAME_1: 'on',
//   FEATURE_FLAG_NAME_2: 'visa'
// }

const featureFlagNames = ['FEATURE_FLAG_NAME_1', 'FEATURE_FLAG_NAME_2'];

const treatments: SplitIO.Treatments = client.getTreatments(featureFlagNames);

// treatments have the following form: 
// {
//   FEATURE_FLAG_NAME_1: 'on',
//   FEATURE_FLAG_NAME_2: 'visa'
// }

var attributes = {
  // date attributes are handled as `millis since epoch`
  registered_date: new Date('YYYY-MM-DDTHH:mm:ss.sssZ').getTime(),
  // this string will be compared against a list called `plan_type`
  plan_type: 'growth',
  // this number will be compared against a const value called `deal_size`
  deal_size: 10000,
  // this boolean will be compared against a const value called `paying_customer`
  paying_customer: true,
  // this array will be compared against a set called `permissions`
  permissions: ["read", "write"]
};

var treatment = client.getTreatment('FEATURE_FLAG_NAME', attributes);

if (treatment === 'on') {
  // insert on code here
} else if (treatment === 'off') {
  // insert off code here
} else {
  // insert control code here
}

const attributes: SplitIO.Attributes = {
  // date attributes are handled as `millis since epoch`
  registered_date: new Date('YYYY-MM-DDTHH:mm:ss.sssZ').getTime(),
  // this string will be compared against a list called `plan_type`
  plan_type: 'growth',
  // this number will be compared against a const value called `deal_size`
  deal_size: 10000,
  // this array will be compared against a set called `permissions`
  permissions: ['read', 'write']
};

const treatment: SplitIO.Treatment = client.getTreatment('FEATURE_FLAG_NAME', attributes);

if (treatment === 'on') {
  // insert on code here
} else if (treatment === 'off') {
  // insert off code here
} else {
  // insert control code here
}

var attributes = {
  registered_date: new Date('YYYY-MM-DDTHH:mm:ss.sssZ').getTime(),
  plan_type: 'growth',
  deal_size: 10000,
  paying_customer: true,
  permissions: ["read", "write"]
};

// set attributes returns true unless there is an issue storing it
var result = client.setAttributes(attributes);

// set one attribute and returns true unless there is an issue storing it
var result = client.setAttribute('paying_customer', false);

// Get an attribute
var plan_type = client.getAttribute('plan_type');

// Get all attributes
var stored_attributes = client.getAttributes();

// Remove an attribute
var result = client.removeAttribute('permissions');

// Remove all attributes
var result = client.clearAttributes();

var TreatmentResult = {
   String treatment;
   String config; // or null if there is no config for the treatment
}

type TreatmentResult = {
    treatment: string,
    config: string | null
  };

var TreatmentResult = client.getTreatmentWithConfig('FEATURE_FLAG_NAME', attributes);
var configs = JSON.parse(TreatmentResult.config);
var treatment = TreatmentResult.treatment;

if (treatment === 'on') {
  // insert on code here and use configs here as necessary
} else if (treatment === 'off') {
  // insert off code here and use configs here as necessary
} else {
  // insert control code here
}

const TreatmentResult: SplitIO.TreatmentWithConfig = client.getTreatmentWithConfig('FEATURE_FLAG_NAME', attributes);
const configs = JSON.parse(TreatmentResult.config);
const treatment = TreatmentResult.treatment;

if (treatment === 'on') {
  // insert on code here and use configs here as necessary
} else if (treatment === 'off') {
  // insert off code here and use configs here as necessary
} else {
  // insert control code here
}

var featureFlagNames = ['FEATURE_FLAG_NAME_1', 'FEATURE_FLAG_NAME_2'];

var TreatmentResults = client.getTreatmentsWithConfig(featureFlagNames);

// TreatmentResults will have the following form: 
// {
//   FEATURE_FLAG_NAME_1: {treatment: 'on',
//                  config: "{ 'color' : 'red'}}",
//   FEATURE_FLAG_NAME_2: {treatment: 'v2',
//                  config: "{ 'copy' : 'better copy'}}",
// }

const featureFlagNames = ['FEATURE_FLAG_NAME_1', 'FEATURE_FLAG_NAME_2'];

const TreatmentResults: SplitIO.TreatmentsWithConfig = client.getTreatmentsWithConfig(featureFlagNames);

// TreatmentResults will have the following form: 
// {
//   FEATURE_FLAG_NAME_1: {treatment: 'on',
//                  config: "{ 'color' : 'red'}}",
//   FEATURE_FLAG_NAME_2: {treatment: 'v2',
//                  config: "{ 'copy' : 'better copy'}}",
// }

// If you have only passed the key to the SDK
var queued = client.track('TRAFFIC_TYPE', 'EVENT_TYPE', eventValue, { properties });
// Example with both a value and properties
var properties = {package : "premium", admin : true, discount : 50};
var queued = client.track('user', 'page_load_time', 83.334, properties);

// Example with only properties
var properties = {package : "premium", admin : true, discount : 50};
var queued = client.track('user', 'page_load_time', null, properties);

// If you have also passed the trafficType on the factory settings or when creating a new client.
var queued = client.track('EVENT_TYPE', eventValue);

// Example with both a value and properties
var properties = {package : "premium", admin : true, discount : 50};
var queued = client.track('page_load_time', 83.334, properties);

// Example with only properties
var properties = {package : "premium", admin : true, discount : 50};
var queued = client.track('page_load_time', null, properties);

// If you have only passed the key to the SDK
const queued: boolean = client.track('TRAFFIC_TYPE', 'EVENT_TYPE', eventValue, , { properties });
// Example with both a value and properties
const properties = {package : "premium", admin : true, discount : 50};
const queued = client.track('user', 'page_load_time', 83.334, properties);

// Example with only properties
const properties = {package : "premium", admin : true, discount : 50};
const queued = client.track('user', 'page_load_time', null, properties);

// If you have also passed the trafficType on the factory settings or when creating a new client.
const queued = client.track('EVENT_TYPE', eventValue);

// Example with both a value and properties
const properties = {package : "premium", admin : true, discount : 50};
const queued = client.track('page_load_time', 83.334, properties);

// Example with only properties
const properties = {package : "premium", admin : true, discount : 50};
const queued = client.track('page_load_time', null, properties);

var sdk = SplitFactory({
  startup: {
    requestTimeoutBeforeReady:     5, // 5 sec
    retriesOnFailureBeforeReady:   1, // 1 sec
    readyTimeout:                 10, // 10 sec
    eventsFirstPushWindow:        10  // 10 sec
  },
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    key: 'USER_ID',
    trafficType: 'YOUR_CUSTOMER_TRAFFIC_TYPE'
  },
  scheduler: {
    featuresRefreshRate:      5, // 5 sec 
    segmentsRefreshRate:     60, // 60 sec 
    impressionsRefreshRate: 300, // 300 sec
    impressionsQueueSize: 30000, // 30000 items
    eventsPushRate:          60, // 60 sec
    eventsQueueSize:        500, // 500 items
    telemetryRefreshRate:  3600  // 1 hour
  },
  sync: {
    splitFilters: [{
      type: 'byName',
      values: ['FEATURE_FLAG_NAME_1', 'FEATURE_FLAG_NAME_2']
    }],
    impressionsMode: 'NONE'
  },
  storage: {
    type: 'LOCALSTORAGE',
    prefix: 'MYPREFIX'
  },
  debug: false
});

const sdk: SplitIO.ISDK = SplitFactory({
  startup: {
    requestTimeoutBeforeReady:     5, // 5 sec
    retriesOnFailureBeforeReady:   1, // 1 sec
    readyTimeout:                 10, // 10 sec
    eventsFirstPushWindow:        10  // 10 sec
  },
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    key: 'USER_ID',
    trafficType: 'YOUR_CUSTOMER_TRAFFIC_TYPE'
  },
  scheduler: {
    featuresRefreshRate:      5, // 5 sec 
    segmentsRefreshRate:     60, // 60 sec 
    impressionsRefreshRate: 300, // 300 sec
    impressionsQueueSize: 30000, // 30000 items
    eventsPushRate:          60, // 60 sec
    eventsQueueSize:        500, // 500 items
    telemetryRefreshRate:  3600  // 1 hour
  },
  sync: {
    splitFilters: [{
      type: 'byName',
      values: ['FEATURE_FLAG_NAME_1', 'FEATURE_FLAG_NAME_2']
    }],
    impressionsMode: 'NONE'
  },
  storage: {
    type: 'LOCALSTORAGE',
    prefix: 'MYPREFIX'
  },
  debug: false
});

var sdk = splitio({
  core: {
    authorizationKey: 'localhost',
    key: 'CUSTOMER_ID'
  },
  features: {
    'reporting_v2': 'on', // example with just a string value for the treatment
    'billing_updates': { treatment: 'visa', config: '{ "color": "blue" }' }, // example of a defined config 
    'show_status_bar': { treatment: 'off', config: null } // example of a null config
  },
  scheduler: {
    offlineRefreshRate: 15 // 15 sec
  }
});

var client = sdk.client();

// The following code will be evaluated once the engine finishes the initialization
client.on(client.Event.SDK_READY, function() {
  // The sentence below will return 'on'
  var t1 = client.getTreatment('reporting_v2') 
  // The sentence below will return an object with the structure of: {treatment:'visa',config:'{ "color":"blue" }'}
  var t2 = client.getTreatmentWithConfig('billing_updates') 
  // The sentence below will return 'control' because that feature does not exist
  var t3 = client.getTreatmentWithConfig('navigation_bar_changes') 
});

// The following code will be evaluated only if using the LocalStorage option as storage type. 
// The only difference with the production mode is that the event is always emitted in localhost mode, 
// since the SDK can evaluate using the features provided by your `features` config object.
client.on(client.Event.SDK_READY_FROM_CACHE, function() {
  // The sentence below will return 'on'
  var t1 = client.getTreatment('reporting_v2') 
}

const sdk: SplitIO.ISDK = SplitFactory({
  core: {
    authorizationKey: 'localhost',
    key: 'CUSTOMER_ID'
  },
  features: {
    'reporting_v2': 'on', // example with just a string value for the treatment
    'billing_updates': { treatment: 'visa', config: '{ "color": "blue"}' } // example of a defined config 
    'show_status_bar': { treatment: 'off', config: null } // example of a null config
  },
  scheduler: {
    offlineRefreshRate: 15 // 15 sec
  }
});

const client: SplitIO.IClient = sdk.client();

// The following code will be evaluated once the engine finishes the initialization
client.on(client.Event.SDK_READY, () => {
  // The sentence below will return 'on'
  const t1: SplitIO.Treatment = client.getTreatment('reporting_v2');
  // The sentence below will return an object with the structure of: {treatment:'visa',config:'{ "color":"blue" }'
  const t2: SplitIO.Treatment = client.getTreatmentWithConfig('billing_updates');
  // The sentence below will return 'control' because that feature does not exist
  const t3: SplitIO.Treatment = client.getTreatmentWithConfig('navigation_bar_changes');
});

// The following code will be evaluated only if using the LocalStorage option as storage type. 
// The only difference with the production mode is that the event is always emitted in localhost mode, 
// since the SDK can evaluate using the features provided by your `features` config object.
client.on(client.Event.SDK_READY_FROM_CACHE, () => {
  // The sentence below will return 'on'
  const t1: SplitIO.Treatment = client.getTreatment('reporting_v2') 
}

var factory = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    // the key can be the logged in
    // user id, or the account id that 
    // the logged in user belongs to. 
    // The type of customer (user, account, custom)
    // is chosen during Split's sign-up process.
    key: 'key'
  }
});

var manager = factory.manager();

manager.once(manager.Event.SDK_READY, function() {
  // Once it's ready, use the manager
});

const factory: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    // the key can be the logged in
    // user id, or the account id that 
    // the logged in user belongs to. 
    // The type of customer (user, account, custom)
    // is chosen during Split's sign-up process.
    key: 'key'
  }
});

const manager: SplitIO.IManager = factory.manager();

manager.once(manager.Event.SDK_READY, function() {
  // Once it's ready, use the manager
});

/**
 * Returns the feature flag registered within the SDK that matches this name.
 *
 * @return SplitView or null.
 */
var splitView = manager.split('name-of-feature-flag');

/**
 * Retrieves all the feature flags that are currently registered within the SDK.
 *
 * returns a List of SplitViews.
 */
var splitViewsList = manager.splits();

/** 
 * Returns the names of all features flags registered within the SDK.
 *
 * @return a List of Strings of the features' names.
 */
var splitNamesList = manager.names();

/**
 * Returns the feature flag registered within the SDK that matches this name.
 *
 * @return SplitView or null.
 */
const splitView: SplitIO.SplitView = manager.split('name-of-feature-flag');

/**
 * Retrieves all the feature flags that are currently registered within the SDK.
 *
 * returns a List of SplitViews.
 */
const splitViewsList: SplitIO.SplitViews = manager.splits();

/** 
 * Returns the names of all features flags registered within the SDK.
 *
 * @return a List of Strings of the features' names.
 */
const splitNamesList: SplitIO.SplitNames = manager.names();

class SplitView {
  name: string,
  trafficType: string,
  killed: boolean,
  treatments: Array<string>,
  changeNumber: number,
  configs: {
    [treatmentName: string]: string
  }    
}

function logImpression(impressionData) {
  // do something with the impression data.
}

var factory = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    key: 'key'
  },
  impressionListener: {
    logImpression: logImpression
  }
});

class MyImprListener implements SplitIO.IImpressionListener {
  logImpression(impressionData: SplitIO.ImpressionData) {
    // do something with impressionData
  }
}

const factory: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    key: 'key'
  },
  impressionListener: {
    logImpression: new MyImprListener()
  }
});

// Acceptable values are 'DEBUG', 'INFO', 'WARN', 'ERROR' and 'NONE'
// Other acceptable values are 'on', 'enable' and 'enabled', which are equivalent to 'DEBUG' log level
localStorage.splitio_debug = 'on' <enter>

var SplitFactory = require('@splitsoftware/splitio').SplitFactory;

var sdk = SplitFactory({
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    key: 'key'
  },
  debug: true // Debug boolean option can be passed on settings
  // It takes precedence over the localStorage flag.
});

// Or you can use the Logger API which two methods, enable and disable.
// Calling this methods will have an immediate effect.
sdk.Logger.enable();
sdk.Logger.disable();

// You can also set the log level programatically after v10.4.0
// Acceptable values are: 'DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'.
// 'DEBUG' is equivalent to `enable` method.
// 'NONE' is equivalent to `disable` method.
sdk.Logger.setLogLevel('WARN');

import { SplitFactory } from '@splitsoftware/splitio';

const sdk: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    key: 'key'
  },
  debug: true // Debug boolean option can be passed on settings.
  // It takes precedence over the localStorage flag.
});

// Or you can use the Logger API which two methods, enable and disable.
// Calling this methods will have an immediate effect.
sdk.Logger.enable();
sdk.Logger.disable();

// You can also set the log level programatically after v10.4.0
// Acceptable values are: 'DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'.
// 'DEBUG' is equivalent to `enable` method.
// 'NONE' is equivalent to `disable` method.
sdk.Logger.setLogLevel('WARN');

var factory = SplitFactory({
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    key: 'USER_ID'
  },
  integrations: [{
    type: 'AN_INTEGRATION_TYPE'
  }, {
    type: 'ANOTHER_INTEGRATION_TYPE',
    // integration specific options would go here
    ...
  }]
});

var factory = SplitFactory({
  core: {
    authorizationKey: 'YOUR_AUTH_KEY',
    key: 'CUSTOMER_ACCOUNT_ID', 
    // Instantiate the sdk once and provide the ID for one of the
    // traffic types that you plan to release to. It doesn't
    // matter which you pick to start off with.
    trafficType: 'A_TRAFFIC_TYPE'
    // You can also provide a traffic type you want to use for 
    // events tracking. This setting is optional, if not provided
    // you can pass the traffic type directly to client.track()
  },
});

// now when you call factory.client(), the sdk will create a client 
// using the Account ID and traffic type name (if any) 
// you passed in during the factory creation.
var account_client = factory.client();

// to create another client for a User instead, just pass in a User ID 
// and an optional Traffic Type to the factory.client() method. 
// This is only valid after at least one client has been initialized.
var user_client = factory.client('CUSTOMER_USER_ID', 'ANOTHER_TRAFFIC_TYPE'); 

// check treatment for user-poll and CUSTOMER_USER_ID
var user_poll_treatment = user_client.getTreatment('user-poll');

// check treatment for account-permissioning and CUSTOMER_ACCOUNT_ID
var account_permissioning_treatment = account_client.getTreatment('account-permissioning');

// track events for accounts
user_client.track('PAGELOAD', 7.86);

// or track events for users
account_client.track('ACCOUNT_CREATED');

const sdk: SplitIO.ISDK = SplitFactory({
  core: {
    authorizationKey: 'YOUR_AUTH_KEY',
    key: 'CUSTOMER_ACCOUNT_ID' 
    // instantiate the sdk once and provide the ID for one of the
    // traffic types that you plan to release to. It doesn't
    // matter which you pick to start off with. 
  },
});

// now when you call sdk.client(), the sdk will create a client
// using the Account ID you passed in during the factory creation.
const account_client: SplitIO.IClient = factory.client();

// to create another client for a User instead, just pass in a
// User ID to the sdk.client() method. This is only valid after 
// at least one client has been initialized.
const user_client: SplitIO.IClient =
  factory.client('CUSTOMER_USER_ID'); 

// check treatment for user-poll and CUSTOMER_USER_ID
const user_poll_treatment: SplitIO.Treatment =
  user_client.getTreatment('user-poll');

// check treatment for account-permissioning and CUSTOMER_ACCOUNT_ID
const account_permissioning_treatment: SplitIO.Treatment =
  account_client.getTreatment('account-permissioning');

function whenReady() {
  var treatment = client.getTreatment('FEATURE_FLAG_NAME');

  if (treatment === 'on') {
    // insert on code
  } else if (treatment === 'off') {
    // insert off code
  } else {
    // insert control code (usually the same as default treatment)
  }
}

// the client is ready to evaluate treatments according to the latest flag definitions
client.once(client.Event.SDK_READY, whenReady);

client.once(client.Event.SDK_READY_TIMED_OUT, function () {
  // this callback will be called after the amount of time defined by startup.readyTimeout if and only if the client
  // is not ready in that time. You can still call getTreatment() 
  // but it could return CONTROL.
});

client.on(client.Event.SDK_UPDATE, function () {
  // fired each time the client state changes. 
  // For example, when a feature flag or segment changes.
  console.log('The SDK has been updated!');
});

// This event only fires using the LocalStorage option and if there's Split data stored in the browser.
client.once(client.Event.SDK_READY_FROM_CACHE, function () {
  // Fired after the SDK could confirm the presence of the Split data.
  // This event fires really quickly, since there's no actual fetching of information.
  // Keep in mind that data might be stale, this is NOT a replacement of SDK_READY.
});

function whenReady() {
  const treatment: SplitIO.Treatment = client.getTreatment('FEATURE_FLAG_NAME');

  if (treatment === 'on') {
    // insert on code
  } else if (treatment === 'off') {
    // insert off code
  } else {
    // insert control code (usually the same as default treatment)
  }
}

// the client is ready for start making evaluations with your data
client.once(client.Event.SDK_READY, whenReady);

client.once(client.Event.SDK_READY_TIMED_OUT, () => {
  // this callback is called after 1.5 seconds if and only if the client
  // is not ready for that time. You can still call getTreatment() 
  // but it could return CONTROL.
});

client.on(client.Event.SDK_UPDATE, () => {
  // fired each time the client state change. 
  // For example, when a feature flag or segment changes.
  console.log('The SDK has been updated!');
});

// This event only fires using the LocalStorage option and if there's Split data stored in the browser.
client.once(client.Event.SDK_READY_FROM_CACHE, function () {
  // Fired after the SDK could confirm the presence of the Split data.
  // This event fires really quickly, since there's no actual fetching of information.
  // Keep in mind that data might be stale, this is NOT a replacement of SDK_READY.
});

var factory = SplitFactory({
  core: {
    authorizationKey: 'YOUR_SDK_KEY',
    key: 'key'
  },
  // Overwrites the initial consent status of the factory instance, which is 'GRANTED' by default.
  // 'UNKNOWN' status represents that the user has neither granted nor declined consent for tracking data, 
  // so the SDK will locally track data but not send it to Split cloud until consent is changed to 'GRANTED'.
  userConsent: 'UNKNOWN'
});


// `getStatus` method returns the current consent status.
factory.UserConsent.getStatus() === factory.UserConsent.Status.UNKNOWN;

// `setStatus` method lets you update the factory consent status at any moment.
// Pass `true` for 'GRANTED' and `false` for 'DECLINED'.
factory.UserConsent.setStatus(true); // Consent status changed from 'UNKNOWN' to 'GRANTED'. Data will be sent to Split cloud.
factory.UserConsent.getStatus() === factory.UserConsent.Status.GRANTED;

factory.UserConsent.setStatus(false); // Consent status changed from 'GRANTED' to 'DECLINED'. Data will not be sent to Split cloud.
factory.UserConsent.getStatus() === factory.UserConsent.Status.DECLINED;