Skip to main content

PHP SDK

Welcome to the developer documentation for the Kameleoon PHP SDK! Our SDK helps you run experiments and activate feature flags on your back-end PHP server. Integrating our SDK into your web-application is easy, and its footprint (in terms of memory and network usage) is low.

Refer to the SDK reference to check out all available methods of the SDK.

Latest version of the PHP SDK: 4.1.0 (changelog).

Getting started

This guide is designed to help you integrate our SDK into your application code.

Installing the SDK

You should first install our SDK. Once uncompressed, you will see two directories: kameleoon/ and job/.

Installing the PHP client (Composer package)

The kameleoon/ directory corresponds to the PHP package itself, which should be used with the Composer dependency manager. Install this directory in your composer hierarchy (so you should have vendor/kameleoon/client/src). Then edit composer.json and add a Kameleoon entry:

"autoload": {
"psr-4": {
"Kameleoon\\": "vendor/kameleoon-php-client/kameleoon/client/src"
}
}

Finally, execute the following command to regenerate the autoloader:

composer dump-autoload -o

Installing the cron job

The job/ directory corresponds to a job that must be executed via a standard job scheduler (like cron). We suggest to install the script itself to /usr/local/opt/kameleoon/kameleoon-client-php-process-queries.sh and to use our default supplied crontab entry. But you can install it in another location and modify the crontab entry accordingly.

Additional configuration

You can customize the behavior of the PHP SDK via a configuration file. We provide a sample configuration file named client-php.json.sample in the SDK archive. We suggest to install this file to the default path of /tmp/kameleoon/client-php.json. With the current version of the PHP SDK, 6 keys are available:

  • client_id: a client_id is required for authentication to the Kameleoon service.
  • client_secret: a client_secret is required for authentication to the Kameleoon service.
  • kameleoon_work_dir: this specifies a working directory for the PHP client (who will create files on this directory). It needs to be writable by the PHP user. If not specified, by default the directory will be /tmp/kameleoon/client-php/.
  • refresh_interval_minute: this specifies the refresh interval, in minutes, of the configuration for experiments and personalizations (the active experiments and personalizations are fetched from the Kameleoon servers). It means that once you launch an experiment, pause it, or stop it the changes can take (at most) the duration of this interval to be propagated in production to your servers. If not specified, the default interval is 60 minutes.
  • default_timeout_millisecond: the parameter sets the time limit for network requests made by the SDK, measured in milliseconds. If this parameter is not defined, the default timeout value is 10_000 milliseconds.
  • cookie_options: this is a map containing configuration options for the kameleoonVisitorCode cookie set by the getVisitorCode() method. Following keys are available:
    • domain: the current top-level domain for your website . Use the format: example.com. Don't include https://, www, or other subdomains. Kameleoon uses this information to set the corresponding cookie on the top-level domain. This field is mandatory.
    • secure: this controls the secure cookie attribute. Default value is false.
    • http_only: this controls the httponly cookie attribute. Default value is false.
    • samesite: this controls the samesite cookie attribute. Default value is None.
  • debug_mode: this parameter sends additional information to our tracking servers to help analyze difficult issues. It should usually be off (false), but activating it (true) has no impact on the SDK performance.
  • environment: an option specifying which feature flag configuration will be used, by default each feature flag is split into production, staging, development. If not specified, will be set to default value of production. More information
note

If you use another path for the configuration file than the default one (/tmp/kameleoon/client-php.json), you will need to:

-pass the path of your configuration file as a third argument to the KameleoonClientFactory::create() method;

  • modify your crontab entry to add the --conf argument to the job script (so for instance it would be called as bash /usr/local/opt/bin/kameleoon-client-php-process-queries.sh --conf /my/path/kameleoon.json).
note

To learn more about client_id and client_secret, as well as how to obtain them, refer to the API credentials article. Note that the Kameleoon PHP SDK uses the Automation API and follows the OAuth 2.0 client credentials flow.

Initializing the Kameleoon client

After installing the SDK into your application and configuring the correct credentials (in /tmp/kameleoon/client-php.json), the next step is to create the Kameleoon client in your application code. For example:

require "vendor/autoload.php";

use Kameleoon;
use Kameleoon\Exception\SiteCodeIsEmpty;
use Kameleoon\Exception\ConfigCredentialsInvalid;

$siteCode = "a8st4f59bj";

try {
// Read from default configuration path: "/tmp/kameleoon/php-client/"
$kameleoonClient = KameleoonClientFactory::create($siteCode);
} catch (SiteCodeIsEmpty $ex) {
// indicates that provided site code is empty
} catch (ConfigCredentialsInvalid $ex) {
// indicates that provided clientId / clientSecret are not valid
}

try {
$kameleoonClient = KameleoonClientFactory::create($siteCode, "custom/file/path/client-php.json");
} catch (SiteCodeIsEmpty $ex) {
// indicates that provided site code is empty
} catch (ConfigCredentialsInvalid $ex) {
// indicates that provided clientId / clientSecret are not valid
}

try {
$cookieOptions = KameleoonClientConfig::createCookies(
"example.com", // domain: optional, but strictly recommended
false, // secure: optional (false by default)
false, // httponly: optional (false by default)
"Lax" // samesite: optional (Lax by default)
)
$config = new KameleoonClientConfig(
"<clientId>", // clientId: mandatory
"<clientSecret>", // clientSecret: mandatory
"/tmp/kameleoon/php-client/", // kameleoonWorkDir: optional / ("/tmp/kameleoon/php-client/" by default)
60, // refreshIntervalMinute: in minutes, optional (60 minutes by default)
10_000, // defaultTimeoutMillisecond: in milliseconds, optional (10_000 ms by default)
false, // debugMode: optional (false by default)
$cookieOptions, // cookieOptions: optional
"development", // environment: optional ("production" by default)
);
$kameleoonClient = KameleoonClientFactory::create($siteCode, $config);
} catch (SiteCodeIsEmpty $ex) {
// indicates that provided site code is empty
} catch (ConfigCredentialsInvalid $ex) {
// indicates that provided clientId / clientSecret are not valid
}

A KameleoonClient is a singleton object that acts as a bridge between your application and the Kameleoon platform. It includes all the methods and properties you will need to run an experiment. Note that the SDK takes its settings from a configuration file. By default, the path /tmp/kameleoon/client-php.json will be used, but you can use a different path for the configuration file by providing an optional third argument to the KameleoonClientFactory::create() method.

note

It's your responsibility as a developer to use correct logic in your application code within the context of A/B testing via Kameleoon. A good practice is to always assume that the current visitor can be left out of the experiment because the experiment has not yet been launched. This is easy to do, because this corresponds to the implementation of the default / reference variation logic. The code samples in the next paragraph show examples of such an approach.

Reference

This is a full reference documentation of the PHP SDK.

If this is your first time working with the PHP SDK, we strongly recommend you go over our Getting started tutorial to integrate the SDK and start experimenting in a few minutes.

Kameleoon\KameleoonClientFactory

create

require "vendor/autoload.php";

use Kameleoon;
use Kameleoon\Exception\SiteCodeIsEmpty;
use Kameleoon\Exception\ConfigCredentialsInvalid;

$siteCode = "a8st4f59bj";

try {
// Read from default configuration path: "/tmp/kameleoon/php-client/"
$kameleoonClient = KameleoonClientFactory::create($siteCode);
} catch (SiteCodeIsEmpty $ex) {
// indicates that provided site code is empty
} catch (ConfigCredentialsInvalid $ex) {
// indicates that provided clientId / clientSecret are not valid
}

try {
$kameleoonClient = KameleoonClientFactory::create($siteCode, "custom/file/path/client-php.json");
} catch (SiteCodeIsEmpty $ex) {
// indicates that provided site code is empty
} catch (ConfigCredentialsInvalid $ex) {
// indicates that provided clientId / clientSecret are not valid
}

This method creates a KameleoonClient instance by providing your SDK configuration in a configuration file. You need to initialize the SDK by creating this instance of KameleoonClient before you can use other SDK methods. All interactions with the SDK use this KameleoonClient instance. To provide the configuration as a KameleoonClientConfig object instead, see the createWithConfig method.

Arguments
NameTypeDescription
siteCodeStringCode of the website you want to run experiments on. This unique code id can be found in our platform's back-office. This field is mandatory.
configurationFilePathStringPath to the SDK configuration file. This field is optional and set to /tmp/kameleoon/client-php.json by default.
Return value
TypeDescription
Kameleoon\KameleoonClientAn instance of the KameleoonClient class, that will be used to manage your experiments and feature flags.
Exceptions thrown
TypeDescription
ConfigCredentialsInvalidException indicating that the requested credentials were not provided (either via the configuration file, or via parameters on the method).

createWithConfig

require "vendor/autoload.php";

use Kameleoon;
use Kameleoon\Exception\SiteCodeIsEmpty;
use Kameleoon\Exception\ConfigCredentialsInvalid;

$siteCode = "a8st4f59bj";

try {
$cookieOptions = KameleoonClientConfig::createCookies(
"example.com", // domain: optional, but strictly recommended
false, // secure: optional (false by default)
false, // httponly: optional (false by default)
"Lax" // samesite: optional (Lax by default)
)
$config = new KameleoonClientConfig(
"<clientId>", // clientId: mandatory
"<clientSecret>", // clientSecret: mandatory
"/tmp/kameleoon/php-client/", // kameleoonWorkDir: optional / ("/tmp/kameleoon/php-client/" by default)
60, // refreshIntervalMinute: in minutes, optional (60 minutes by default)
10_000, // defaultTimeoutMillisecond: in milliseconds, optional (10_000 ms by default)
false, // debugMode: optional (false by default)
$cookieOptions, // cookieOptions: optional
"development", // environment: optional ("production" by default)
);
$kameleoonClient = KameleoonClientFactory::create($siteCode, $config);
} catch (SiteCodeIsEmpty $ex) {
// indicates that provided site code is empty
} catch (ConfigCredentialsInvalid $ex) {
// indicates that provided clientId / clientSecret are not valid
}

This method creates a KameleoonClient instance and allows you to pass your SDK configuration in a KameleoonClientConfig object. You need to initialize the SDK by creating this KameleoonClient instance before you can use other SDK methods. All interactions with the SDK use this KameleoonClient instance. To provide your SDK configuration in a file instead, use the create method.

Arguments
NameTypeDescription
siteCodeStringCode of the website you want to run experiments on. This unique code ID can be found in the Kameleoon app. This field is mandatory.
kameleoonConfigKameleoonClientConfigConfiguration SDK object that you pass. This field is optional.
Return value
TypeDescription
KameleoonClientAn instance of the KameleoonClient class that you use to manage your experiments and feature flags.
Exceptions thrown
TypeDescription
SiteCodeIsEmptyException indicating that the requested credentials were not provided (either using the configuration file or the config parameter in the method).
ConfigCredentialsInvalidException indicating that the requested credentials were not provided (either using the configuration file or the config parameter in the method).

Kameleoon\KameleoonClient

getVisitorCode

require "vendor/autoload.php";

// The cookie's domain must be provided in the configuration file if no argument is given

$visitorCode = $kameleoonClient->getVisitorCode();
$visitorCode = $kameleoonClient->getVisitorCode($defaultVisitorCode); // default visitor code provided
note

This method was previously named obtainVisitorCode, which was removed in SDK version 4.0.0.

This helper method should be called to obtain the Kameleoon visitorCode for the current visitor. This is especially important when using Kameleoon in a mixed front-end and back-end environment, where user identification consistency must be guaranteed. The implementation logic is described here:

  1. First we check if a kameleoonVisitorCode cookie or query parameter associated with the current HTTP request can be found. If so, we will use this as the visitor identifier.

  2. If no cookie / parameter is found in the current request, we either randomly generate a new identifier, or use the defaultVisitorCode argument as identifier if it is passed. This allows our customers to use their own identifiers as visitor codes, should they wish to. This can have the added benefit of matching Kameleoon visitors with their own users without any additional look-ups in a matching table.

  3. In any case, the server-side (via HTTP header) kameleoonVisitorCode cookie is set with the value. Then this identifier value is finally returned by the method.

For more information, refer to this article.

note

If you provide your own visitorCode, its uniqueness must be guaranteed on your end - the SDK cannot check it. Also note that the length of visitorCode is limited to 255 characters. Any excess characters will throw an exception.

Arguments
NameTypeDescription
defaultVisitorCodeStringThis parameter will be used as the visitorCode if no existing kameleoonVisitorCode cookie is found on the request. This field is optional, and by default a random visitorCode will be generated.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
StringA visitorCode that will be associated with this particular user and should be used with most of the methods of the SDK.
Exceptions thrown
TypeDescription
InvalidArgumentExceptionException indicating that the cookie's domain value was not provided (either via the configuration file, or via the topLevelDomain parameter on the method).

isFeatureActive

$visitorCode = $kameleoonClient->getVisitorCode("example.com");
$featureKey = "new_checkout";
$hasNewCheckout = false;

try {
$hasNewCheckout = $kameleoonClient->isFeatureActive($visitorCode, $featureKey);
}
catch (Kameleoon\Exception\FeatureNotFound $e) {
// Feature toggle not yet activated on Kameleoon's side - we consider the feature inactive
$hasNewCheckout = false;
}
catch (Kameleoon\Exception\VisitorCodeInvalid $e) {
// VisitorCode which you passed to a method is invalid and can't be accepte
}
catch (Kameleoon\Exception\DataFileInvalid $e) {
// It appears that the configuration has not been loaded and there is no previously saved version of the configuration available.
}
catch (Exception $e) {
// This is generic Exception handler which will handle all exceptions.
echo "Exception: ", $e->getMessage(), "\n";
}
if ($hasNewCheckout)
{
// Implement new checkout code here
}
note

This method was previously named activateFeature, which was removed in SDK version 4.0.0.

This method takes a visitorCode and featureKey as mandatory arguments to check if the specified feature will be active for a given user.

If such a user has never been associated with this feature flag, the SDK returns a boolean value randomly (true if the user should have this feature or false if not). If a user with a given visitorCode is already registered with this feature flag, it will detect the previous FeatureFlag value.

You have to make sure that proper error handling is set up in your code as shown in the example to the right to catch potential exceptions.

Arguments
NameTypeDescription
visitorCodestringUnique identifier of the user. This field is mandatory.
featureKeystringKey of the feature you want to expose to a user. This field is mandatory.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
boolValue of the feature that is registered for a given visitorCode.
Exceptions thrown
TypeDescription
FeatureNotFoundException indicating that the requested feature ID has not been found in the internal configuration of the SDK. This is usually normal and means that the feature flag has not yet been activated on Kameleoon's side (but code implementing the feature is already deployed on the web-application's side).
VisitorCodeInvalidException indicating that the provided visitor code is not valid (empty, or longer than 255 characters).
DataFileInvalidException indicating that the configuration has not been loaded and there is no previously saved version of the configuration available.

getFeatureVariationKey

$visitorCode = $kameleoonClient->getVisitorCode();
$featureKey = "featureKey";
$variationKey = "";

try {
$variationKey = $kameleoonClient->getFeatureVariationKey($visitorCode, $featureKey);
switch ($variationKey) {
case "on":
// Main variation key is selected for visitorCode
case "alternativeVariation":
// Alternative variation key
default:
// Default variation key
}
}
catch (Kameleoon\Exception\FeatureNotFound $e) {
// Feature toggle not yet activated on Kameleoon's side - we consider the feature inactive
}
catch (Kameleoon\Exception\DataFileInvalid $e) {
// It appears that the configuration has not been loaded and there is no previously saved version of the configuration available.
}
catch (Kameleoon\Exception\VisitorCodeInvalid $e) {
// VisitorCode which you passed to a method is invalid and can't be accepte
}
catch (Kameleoon\Exception\FeatureEnvironmentDisabled){
// The feature flag is disabled for the environment
}
catch (Exception $e) {
// This is generic Exception handler which will handle all exceptions.
echo "Exception: ", $e->getMessage(), "\n";
}

To get feature variation key, call the getFeatureVariationKey() method of our SDK.

This method takes a visitorCode and featureKey as mandatory arguments to get variation key for a given user.

If such a user has never been associated with this feature flag, the SDK returns a variation key randomly (according to the feature flag rules). If a user with a given visitorCode is already registered with this feature flag, it will detect the previous variation key value. If the user does not match any of the rules, the default value will be returned, which we can define in your customer's account.

You have to make sure that proper error handling is set up in your code as shown in the example to the right to catch potential exceptions.

Arguments
NameTypeDescription
visitorCodestringUnique identifier of the user. This field is mandatory.
featureKeystringKey of the feature you want to expose to a user. This field is mandatory.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
stringVariation key of the feature flag that is registered for a given visitorCode.
Exceptions thrown
TypeDescription
FeatureNotFoundException indicating that the requested feature ID has not been found in the internal configuration of the SDK. This is usually normal and means that the feature flag has not yet been activated on Kameleoon's side (but code implementing the feature is already deployed on the web-application's side).
FeatureEnvironmentDisabledException indicating that feature flag is disabled for the visitor's current environment (for example, production, staging, or development).
VisitorCodeInvalidException indicating that the provided visitor code is not valid (empty, or longer than 255 characters).
DataFileInvalidException indicating that the configuration has not been loaded and there is no previously saved version of the configuration available.

getFeatureVariable

$visitorCode = $kameleoonClient->getVisitorCode();
$featureKey = "featureKey";
$variableName = "variableName"

try {
$variationValue = $kameleoonClient->getFeatureVariable($visitorCode, $featureKey, $variableName);
// Your custom code depending of variableValue
}
catch (Kameleoon\Exception\FeatureNotFound $e) {
// Feature toggle not yet activated on Kameleoon's side - we consider the feature inactive
}
catch (Kameleoon\Exception\FeatureEnvironmentDisabled){
// The feature flag is disabled for the environment
}
catch (Kameleoon\Exception\VisitorCodeInvalid $e) {
// VisitorCode which you passed to a method is invalid and can't be accepte
}
catch (Kameleoon\Exception\FeatureVariableNotFound $e) {
// Requested variable not defined on Kameleoon's side
}
catch (Kameleoon\Exception\DataFileInvalid $e) {
// It appears that the configuration has not been loaded and there is no previously saved version of the configuration available.
}
catch (Exception $e) {
// This is generic Exception handler which will handle all exceptions.
echo "Exception: ", $e->getMessage(), "\n";
}
note

Previously named: obtainFeatureVariable. Deprecated since SDK version 3.0.0 and will be removed in a future releases.

To get variable of variation key associated with a user, call the getFeatureVariable() method of our SDK.

This method takes a visitorCode, featureKey and variableName as mandatory arguments to get a variable of variation key for a given user.

If such a user has never been associated with this feature flag, the SDK returns a variable value of variation key randomly (according to the feature flag rules). If a user with a given visitorCode is already registered with this feature flag, it will detect the variable value for previous associated variation. If the user does not match any of the rules, the variable of default value will be returned.

You have to make sure that proper error handling is set up in your code as shown in the example to the right to catch potential exceptions.

Arguments
NameTypeDescription
visitorCodestringUnique identifier of the user. This field is mandatory.
featureKeystringKey of the feature you want to expose to a user. This field is mandatory.
variableNamestringName of the variable you want to get a value. This field is mandatory.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
AnyValue of variable of variation that is registered for a given visitorCode for this feature flag. Possible types: bool, int, float, string, object, array
Exceptions thrown
TypeDescription
FeatureNotFoundException indicating that the requested feature ID has not been found in the internal configuration of the SDK. This is usually normal and means that the feature flag has not yet been activated on Kameleoon's side (but code implementing the feature is already deployed on the web-application's side).
FeatureEnvironmentDisabledException indicating that feature flag is disabled for the visitor's current environment (for example, production, staging, or development).
VisitorCodeInvalidException indicating that the provided visitor code is not valid (empty, or longer than 255 characters).
FeatureVariableNotFoundException indicating that the requested variable has not been found. Check that the variable's ID (or key) matches the one in your code.
DataFileInvalidException indicating that the configuration has not been loaded and there is no previously saved version of the configuration available.

getFeatureVariationVariables

$featureKey = "test_feature_variables";
$variationKey = "on";

try {
$variables = $kameleoonClient->getFeatureVariationVariables($featureKey, $variationKey);
$firstName = $variables["firstName"];
}
catch (Kameleoon\Exception\FeatureNotFound $e) {
// The feature is not yet activated on Kameleoon's side
}
catch (Kameleoon\Exception\FeatureEnvironmentDisabled){
// The feature flag is disabled for the environment
}
catch (Kameleoon\Exception\FeatureVariationNotFound $e) {
// The variation is not yet activated on Kameleoon's side, ie the associated experiment is not online
}
catch (Kameleoon\Exception\DataFileInvalid $e) {
// It appears that the configuration has not been loaded and there is no previously saved version of the configuration available.
}
catch (Exception $e) {
// This is generic Exception handler which will handle all exceptions.
echo "Exception: ", $e->getMessage(), "\n";
}
note

This method was previously named getFeatureAllVariables, which was removed in SDK version 4.0.0.

To retrieve the all feature variables, call the getFeatureVariationVariables() method of our SDK. A feature variable can be changed easily via our web application.

This method takes featureKey and variationKey as mandatory arguments. It will return the data with the object type, as defined on the web interface. Throws an error (FeatureNotFound) if the requested feature flag has not been found in the client configuration of the SDK. If variation key isn't found the method throws (FeatureVariationNotFound) error.

Arguments
NameTypeDescription
featureKeystringKey of the feature flag you want to obtain. This field is mandatory.
variationKeystringKey of the variation you want to obtain. This field is mandatory.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
AnyValue of variable of variation that is registered for a given visitorCode for this feature flag. Possible types: bool, int, float, string, object, array
Exceptions thrown
TypeDescription
FeatureNotFoundException indicating that the requested feature ID has not been found in the internal configuration of the SDK. This is usually normal and means that the feature flag has not yet been activated on Kameleoon's side (but code implementing the feature is already deployed on the web-application's side).
FeatureEnvironmentDisabledException indicating that feature flag is disabled for the visitor's current environment (for example, production, staging, or development).
FeatureVariationNotFoundException indicating that the requested variation ID has not been found in the internal configuration of the SDK. This is usually normal and means that the variation's corresponding experiment has not yet been activated on Kameleoon's side.
DataFileInvalidException indicating that the configuration has not been loaded and there is no previously saved version of the configuration available.

trackConversion

require "vendor/autoload.php";

$kameleoonClient = Kameleoon\KameleoonClientFactory::create("a8st4f59bj", false, "/tmp/kameleoon/client-php.json");
$visitorCode = $kameleoonClient->getVisitorCode();
$goalID = 83023;

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Browser(Kameleoon\Data\Browser::$browsers["CHROME"]));
$kameleoonClient->addData(
$visitorCode,
new Kameleoon\Data\PageView("https://url.com", "title", array(3)),
new Kameleoon\Data\Interest(2)
);
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Conversion(32, 10, false));

$kameleoonClient->trackConversion($visitorCode, $goalID);

To track conversion, use the trackConversion() method. This method requires visitorCode and goalID to track conversion on this particular goal. In addition, this method also accepts revenue as a third optional argument to track revenue. The visitorCode usually is identical to the one that was used when triggering the experiment.

The trackConversion() method doesn't return any value. This method is non-blocking as the server call is made asynchronously.

Arguments
NameTypeDescription
visitorCodeStringUnique identifier of the user. This field is mandatory.
goalIDIntegerID of the goal. This field is mandatory.
revenueFloatRevenue of the conversion. This field is optional.

addData

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Browser(Kameleoon\Data\Browser::$browsers["CHROME"]));
$kameleoonClient->addData(
$visitorCode,
new Kameleoon\Data\PageView("https://url.com", "title", array(3)),
new Kameleoon\Data\Interest(0)
);
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Conversion(32, 10, false));

The addData() method adds targeting data to storage so other methods can use the data to decide whether or not to target the current visitor.

The addData() method does not return any value and does not interact with Kameleoon back-end servers on its own. Instead, all the declared data is saved for future transmission using the flush method. This approach reduces the number of server calls made, as the data is typically grouped into a single server call that is triggered the flush. Noe that the trackConversion method also sends out any previously associated data, just like the flush method. The same is true for getFeatureFlagVariationKey and getFeatureFlagVariable methods if an experimentation rule is triggered.

tip

Each visitor can only have one instance of associated data for most data types. However, CustomData is an exception. Visitors can have one instance of associated CustomData per customDataIndex.

Arguments
NameTypeDescription
visitorCodeStringUnique identifier of the user. This field is mandatory.
dataTypesDataCustom data types which may be passed separated by a comma.

flush

$visitorCode = $kameleoonClient->getVisitorCode();

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Browser(Kameleoon\Data\Browser::$browsers["CHROME"]));
$kameleoonClient->addData(
$visitorCode,
new Kameleoon\Data\PageView("https://url.com", "title", array(3)),
new Kameleoon\Data\Interest(0)
);
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Conversion(32, 10, false));

$kameleoonClient->flush($visitorCode);

Data associated with the current user via addData() method is not sent immediately to the server. It is stored and accumulated until it is sent automatically by the trackConversion() method, or manually by the flush() method. This allows the developer to control exactly when the data is flushed to our servers. For instance, if you call the addData() method a dozen times, it would be a waste of ressources to send data to the server after each addData() invocation. Just call flush() once at the end.

The flush() method doesn't return any value. This method is non-blocking as the server call is made asynchronously.

Arguments
NameTypeDescription
visitorCodeStringUnique identifier of the user. This field is mandatory.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.

getFeatureList

$arrayFeatureKeys = $kameleoonClient->getFeatureList();

Returns a list of feature flag keys currently available for the SDK

Arguments
NameTypeDescription
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
arrayList of feature flag keys
Exceptions thrown
TypeDescription
DataFileInvalidException indicating that the configuration has not been loaded and there is no previously saved version of the configuration available.

getActiveFeatureListForVisitor

$visitorCode = "visitor"
$arrayFeatureFlagKeys = $kameleoonClient->getActiveFeatureListForVisitor($visitorCode)

This method takes only input parameters: visitorCode. Result contains only active feature flags for a given visitor.

Arguments
NameTypeDescription
visitorCodestringUnique identifier of the user. This field is mandatory.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
anyList of feature flag keys which are active for a given visitorCode
Exceptions thrown
TypeDescription
VisitorCodeInvalidException indicating that the provided visitor code is not valid (empty, or longer than 255 characters).
DataFileInvalidException indicating that the configuration has not been loaded and there is no previously saved version of the configuration available.

getRemoteData

note

This method was previously named retrieveDataFromRemoteSource, which was removed in SDK version 4.0.0.

$test_value = $kameleoonClient->getRemoteData("test") // default timeout will be used
$test_value = $kameleoonClient->getRemoteData("test", 1000) // 1000 milliseconds timeout
try {
$test_value = $kameleoonClient->getRemoteData("test");
} catch (Exception $e) {
// Timeout or Json Decoding Exception
}

The getRemoteData() method allows you to retrieve data (according to a key passed as argument) for specified siteCode (specified in KameleoonClientFactory.create()) stored on a remote Kameleoon server. Usually data will be stored on our remote servers via the use of our Data API. This method, along with the availability of our highly scalable servers for this purpose, provides a convenient way to quickly store massive amounts of data that can be later retrieved for each of your visitors / users.

Arguments
NameTypeDescription
keystringThe key that the data you try to get is associated with. This field is mandatory.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
ObjectObject associated with retrieving data for specific key.
Exceptions thrown
TypeDescription
ExceptionException indicating that the request timed out or retrieved data can't be decoded with json_decode method

getRemoteVisitorData

The getRemoteVisitorData method allows you to retrieve custom data stored on remote Kameleoon servers for a visitor (specified using the visitorCode argument). If addData is true, this method automatically adds the retrieved data to a visitor without requiring you to make a separate addData call. You must call KameleoonClientFactory::create to provide your siteCode before calling this method.

You also must have previously stored data on our remote servers, which you can add with any of the following tracking calls in the SDK:

  • flush
  • getFeatureVariationKey
  • getFeatureVariable
  • isFeatureActive

Using the getRemoteVisitorData method along with the availability of our highly scalable servers provides a convenient way to quickly access and synchronize large amounts of data across all of the visitor's devices.

Arguments
NameTypeDescription
visitorCodestringThe visitor code for which you want to retrieve the assigned data. This field is mandatory.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
addDataboolA boolean indicating whether the method should automatically add retrieved data for a visitor. If not specified, the default value is true. This field is optional.

Example code

$visitorCode = "visitorCode";

// Visitor data will be fetched and automatically added for `visitorCode`
$data_array = $kameleoonClient->getRemoteVisitorData($visitorCode, null); // default timeout will be used
$data_array = $kameleoonClient->getRemoteVisitorData($visitorCode, 1000); // 1000 milliseconds timeout

// If you only want to fetch data and add it yourself manually, set shouldAddData == `false`
$data_array = $kameleoonClient->getRemoteVisitorData(visitorCode, null, false); // default timeout will be used
$data_array = $kameleoonClient->getRemoteVisitorData(visitorCode, 1000, false); // 1000 milliseconds timeout

getVisitorWarehouseAudience

Retrieves all audience data associated with the visitor in your data warehouse using the specified visitorCode and warehouseKey. The warehouseKey is typically your internal user ID. The customDataIndex parameter corresponds to the Kameleoon custom data that Kameleoon uses to target your visitors. You can refer to the warehouse targeting documentation for additional details. The method passes the result to the returned future as a CustomData object, confirming that the data has been added to the visitor and is available for targeting purposes.

Arguments
NameTypeDescription
visitorCodestringThe unique identifier of the visitor for whom you want to retrieve and add the data.
customDataIndexintAn integer representing the index of the custom data you want to use to target your BigQuery Audiences.
warehouseKeystringThe unique key to identify the warehouse data (usually, your internal user ID). This field is optional.
timeout?intTimeout (in milliseconds). This parameter specifies the maximum amount of time the method can block to wait for a result. This field is optional. If a timeout value is not provided, the SDK uses the default_timeout specified in your configuration.
Return value
TypeDescription
?CustomdataCustomData instance confirming that the data has been added to the visitor. If value is null, the request is failed and CustomData wasn't added to the visitor.
Exceptions thrown
TypeDescription
VisitorCodeInvalidException indicating that the provided visitor code is not valid (it is either empty or longer than 255 characters).
Example code
$warehouseAudienceCustomData = $kameleoonClient->getVisitorWarehouseAudience(visitorCode, customDataIndex);

// If you need to specify warehouse key
$warehouseAudienceCustomData = $kameleoonClient->getVisitorWarehouseAudience(visitorCode, customDataIndex, warehouseKeyValue);

// If you need to specify warehouse key & timeout
$warehouseAudienceCustomData = $kameleoonClient->getVisitorWarehouseAudience(visitorCode, customDataIndex, warehouseKeyValue, 2000);

getEngineTrackingCode

engineTrackingCode := $kameleoonClient->getEngineTrackingCode($visitorCode)
// Example JavaScript code that can be returned:
//
// window.kameleoonQueue = window.kameleoonQueue || [];
// window.kameleoonQueue.push(['Experiments.assignVariation', experiment1ID, variation1ID]);
// window.kameleoonQueue.push(['Experiments.trigger', experiment1ID, true]);
// window.kameleoonQueue.push(['Experiments.assignVariation', experiment2ID, variation2ID]);
// window.kameleoonQueue.push(['Experiments.trigger', experiment2ID, true]);
//
// Here, experiment1ID, experiment2ID and variation1ID, variation2ID represent
// the specific experiments and variations that the specified user has been assigned to

Kameleoon offers built-in integrations with various analytics and CDP solutions, such as Mixpanel, Google Analytics 4, Segment.... To ensure that you can track and analyze your server-side experiments, Kameleoon provides a method GetEngineTrackingCode() that returns the JavasScript code to be inserted in your page to send automatically the exposure events to the analytics solution you are using.The SDK builds a tracking code for your active analytics solution based on the experiments that the visitor has triggered in the last 5 seconds. For more information about hybrid experimentation, please refer to this documentation.

note

To benefit from this feature, you will need to implement both the PHP SDK and our Kameleoon JavaScript tag. We recommend you implement the Kameleoon Asynchronous tag, which you can install before your closing <body> tag in your HTML page, as it will be only used for tracking purposes.

Arguments
NameTypeDescription
visitorCodestringThe user's unique identifier. This field is mandatory.
Return value
TypeDescription
stringJavaScript code to be inserted in your page

SetLegalConsent

You must use this method to specify whether the visitor has given legal consent to use personal data. Setting the legalConsent parameter to false limits the types of data that you can include in tracking requests. This helps you adhere to legal and regulatory requirements while responsibly managing visitor data. You can find more information on personal data in the Consent management policy.

Arguments
NameTypeDescription
visitorCodestringThe user's unique identifier. This field is required.
legalConsentboolA boolean value representing the legal consent status. true indicates the visitor has given legal consent, false indicates the visitor has never provided, or has withdrawn, legal consent. This field is required.
Exceptions thrown
TypeDescription
VisitorCodeInvalidException indicating that the provided visitor code is not valid (empty, or longer than 255 characters).
Example code
$visitorCode = $kameleoonClient->getVisitorCode();
$kameleoonClient->setLegalConsent($visitorCode, true);

Kameleoon\Data

Browser

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Browser(Kameleoon\Data\Browser::$browsers["CHROME"]));
NameTypeDescription
browserAssociative ArrayList of browsers: CHROME, INTERNET_EXPLORER, FIREFOX, SAFARI, OPERA, OTHER. This field is mandatory.

PageView

$kameleoonClient->addData(
$visitorCode,
new Kameleoon\Data\PageView("https://url.com", "title", array(3))
);
NameTypeDescription
urlStringURL of the page viewed. This field is mandatory.
titleStringTitle of the page viewed. This field is mandatory.
referrersarrayReferrers of viewed pages. This field is optional.
note

The index (ID) of the referrer is available on our Back-Office, in the Acquisition channel configuration page. Be careful: this index starts at 0, so the first acquisition channel you create for a given site would have the ID 0, not 1.
https://help.kameleoon.com/create-acquisition-channel

Conversion Data Type

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Conversion(32, 10, false));
NameTypeDescription
goalIDIntegerID of the goal. This field is mandatory.
revenueFloatConversion revenue. This field is optional.
negativeBooleanDefines if the revenue is positive or negative. This field is optional.

CustomData

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\CustomData(1, "some custom value"));
NameTypeDescription
indexIntegerIndex / ID of the custom data to be stored. This field is mandatory.
valueStringValue of the custom data to be stored. This field is mandatory.
note

The index (ID) of the custom data is available on our Back-Office, in the Custom data configuration page. Be careful: this index starts at 0, so the first custom data you create for a given site would have the ID 0, not 1.

Device

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Device(Kameleoon\Data\Device::PHONE));
NameTypeDescription
typeintList of devices: PHONE, TABLET, DESKTOP. This field is mandatory.

UserAgent

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\UserAgent("TestUserAgent"));
NameTypeDescription
valuestringThe User-Agent value that will be sent with tracking requests. This field is mandatory.

Store information on the user-agent of the visitor. Server-side experiments are more vulnerable to bot traffic than client-side experiments. To address this, Kameleoon uses the IAB/ABC International Spiders and Bots List to identify known bots and spiders. Kameleoon also uses the UserAgent field to filter out bots and other unwanted traffic that could otherwise skew your conversion metrics. For more details, see the help article on Bot filtering.

If you use internal bots, we suggest that you pass the value curl/8.0 of the userAgent to exclude them from our analytics.

Targeting conditions

The Kameleoon SDKs support a variety of predefined targeting conditions that you can use to target users in your campaigns. For the list of conditions supported by this SDK, see Use visit history to target users.

You can also use your own external data to target users.