PHP SDK

composer install

require "vendor/autoload.php";

use Kameleoon\KameleoonClientConfig;
use Kameleoon\KameleoonClientFactory;
use Kameleoon\Exception\ConfigCredentialsInvalid;
use Kameleoon\Exception\KameleoonException;
use Kameleoon\Exception\SiteCodeIsEmpty;

$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
} catch (KameleoonException $ex) {
    // probably indicates that the SDK is unable to access the **Kameleoon working directory**
}

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
} catch (KameleoonException $ex) {
    // probably indicates that the SDK is unable to access the **Kameleoon working directory**
}

try {
    $cookieOptions = KameleoonClientConfig::createCookieOptions(
        "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)
        "example.com", // networkDomain: optional (null by default)
        1024*1024, // requestBodySizeLimitBytes: optional (2560 * 1024 by default)
    );
    $kameleoonClient = KameleoonClientFactory::createWithConfig($siteCode, $config);
} catch (SiteCodeIsEmpty $ex) {
    // indicates that provided site code is empty
} catch (ConfigCredentialsInvalid $ex) {
    // indicates that provided clientId / clientSecret are not valid
} catch (KameleoonException $ex) {
    // probably indicates that the SDK is unable to access the **Kameleoon working directory**
}

// In this example, `91` represents the Custom Data's index
// configured as a unique identifier in Kameleoon.
const MAPPING_INDEX = 91;
const FEATURE_KEY = "ff123";

// 1. Before the visitor is authenticated

// Retrieve the variation for an unauthenticated visitor.
// Assume `anonymousVisitorCode` is the randomly generated ID for that visitor.
$anonymousVariation = $kameleoonClient->getVariation($anonymousVisitorCode, FEATURE_KEY);

// 2. After the visitor is authenticated

// Assume `userId` is the authenticates visitor's visitor code.
$kameleoonClient->addData($anonymousVisitorCode, new CustomData(MAPPING_INDEX, $userId));
$kameleoonClient->flush($anonymousVisitorCode, null, null, true);

// Indicate that `userId` is a unique identifier.
$kameleoonClient->addData($userId, new UniqueIdentifier(true));

// 3. After the visitor has been authenticated

// Retrieve the variation for the `userId`, which will match the anonymous visitor code's variation.
$userVariation = $kameleoonClient->getVariation($userId, FEATURE_KEY);
$isSameVariation = $userVariation->key == $anonymousVariation->key; // true

// The `userId` and `anonymousVisitorCode` are now linked and tracked as a single visitor.
$kameleoonClient->trackConversion($userId, 123, 10.0);

// Additionally, the linked visitors will share all fetched remote visitor data.
$kameleoonClient->getRemoteVisitorData($userId);

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\CustomData(1, "newVisitorCode"));

use Kameleoon\logging\KameleoonLogger;
use Kameleoon\logging\LogLevel;

// The `NONE` log level does not allow logging.
KameleoonLogger::setLogger(LogLevel::NONE);

// The `ERROR` log level only allows logging issues that may affect the SDK's primary behavior.
KameleoonLogger::setLogger(LogLevel::ERROR);

// The `WARNING` log level allows logging issues which may require additional attention.
// It extends the `ERROR` log level.
// The `WARNING` log level is a default log level.
KameleoonLogger::setLogger(LogLevel::WARNING);

// The `INFO` log level allows logging general information on the SDK's internal processes.
// It extends the `WARNING` log level.
KameleoonLogger::setLogger(LogLevel::INFO);

// The `DEBUG` level logs additional details about the SDK’s internal processes and extends the `INFO` level
// with more granular. diagnostic output.
// This information is not intended for end-user interpretation but can be sent to our support team
// to assist with internal troubleshooting.
KameleoonLogger::setLogger(LogLevel::DEBUG);

use Kameleoon\logging\KameleoonLogger;
use Kameleoon\logging\Logger;
use Kameleoon\logging\LogLevel;
use Monolog\Logger as MonologLogger;

public class CustomLogger implements Logger {
    // Monolog logger
    private MonologLogger $inner;

    public function __construct(MonologLogger $inner)
    {
        $this->inner = $inner;
    }

    // `log` method accepts logs from the SDK
    public function log($level, string $message): void
    {
        // Custom log handling logic here. For example:
        switch ($level) {
            case LogLevel::ERROR:
                $this->inner->error($message);
                break;
            case LogLevel::WARNING:
                $this->inner->warning($message);
                break;
            case LogLevel::INFO:
                $this->inner->info($message);
                break;
            case LogLevel::DEBUG:
                $this->inner->debug($message);
                break;
        }
    }
}


// Log level filtering is applied separately from log handling logic.
// The custom logger will only accept logs that meet or exceed the specified log level.
// Ensure the log level is set correctly.
KameleoonLogger::setLogLevel(LogLevel::DEBUG); // Optional; defaults to `LogLevel::WARNING`.
KameleoonLogger::setLogger(new CustomLogger($inner));

require "vendor/autoload.php";

use Kameleoon\KameleoonClientFactory;
use Kameleoon\Exception\ConfigCredentialsInvalid;
use Kameleoon\Exception\KameleoonException;
use Kameleoon\Exception\SiteCodeIsEmpty;

$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
} catch (KameleoonException $ex) {
    // probably indicates that the SDK is unable to access the **Kameleoon working directory**
}

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
} catch (KameleoonException $ex) {
    // probably indicates that the SDK is unable to access the **Kameleoon working directory**
}

require "vendor/autoload.php";

use Kameleoon\KameleoonClientConfig;
use Kameleoon\KameleoonClientFactory;
use Kameleoon\Exception\ConfigCredentialsInvalid;
use Kameleoon\Exception\KameleoonException;
use Kameleoon\Exception\SiteCodeIsEmpty;

$siteCode = "a8st4f59bj";

try {
    $cookieOptions = KameleoonClientConfig::createCookieOptions(
        "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)
        "example.com", // networkDomain: optional (null by default)
        1024*1024, // requestBodySizeLimitBytes: optional (2560 * 1024 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
} catch (KameleoonException $ex) {
    // probably indicates that the SDK is unable to access the **Kameleoon working directory**
}

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

try {
    $hasNewCheckout = $kameleoonClient->isFeatureActive($visitorCode, $featureKey, $timeout);
    // disabling tracking
    $hasNewCheckout = $kameleoonClient->isFeatureActive($visitorCode, $featureKey, $timeout, null, false);
} 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 accepted.
} 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 a generic Exception handler which will handle all exceptions.
    echo "Exception: ",  $e->getMessage(), "\n";
}
if ($hasNewCheckout) {
    // Implement new checkout code here.
}

$featureKey = "new_checkout";

try {
    $variation = $kameleoonClient->getVariation($visitorCode, $featureKey);
    // disabling tracking
    $variation = $kameleoonClient->getVariation($visitorCode, $featureKey, false);
} catch (Kameleoon\Exception\FeatureNotFound $e) {
    // An error has occurred; the feature flag isn't found in the current configuration.
} catch (Kameleoon\Exception\FeatureEnvironmentDisabled $e) {
    // The feature flag is disabled for the environment.
} catch (Kameleoon\Exception\VisitorCodeInvalid $e) {
    // The visitor code you passed to the method is invalid and can't be accepted by the SDK.
}

// Fetch a variable value for the assigned variation
$title = $variation->variables["title"]->value;

switch ($variation->key) {
    case "on":
        // Main variation key is selected for visitorCode
        break;
    case "alternative_variation":
        // Alternative variation key
        break;
    default:
        // Default variation key
        break;
}

try {
    $variations = $kameleoonClient->getVariations($visitorCode);
    // only active variations
    $variations = $kameleoonClient->getVariations($visitorCode, true);
    // disable tracking
    $variations = $kameleoonClient->getVariations($visitorCode, $onlyActive, false);
} catch (Kameleoon\Exception\VisitorCodeInvalid $e) {
    // Handle exception
}

$experimentId = 9516;
try {
    // Forcing the variation "on" for the experiment 9516 for the visitor
    $kameleoonClient->setForcedVariation($visitorCode, $experimentId, "on");

    // Forcing the variation "on" while preserving segmentation and targeting conditions during the experiment
    $kameleoonClient->setForcedVariation($visitorCode, $experimentId, "on", false);

    // Resetting the forced variation for the experiment 9516 for the visitor
    $kameleoonClient->setForcedVariation($visitorCode, $experimentId, null);
} catch (Kameleoon\Exception\KameleoonException $e) {
    // Handling the error
}

try {
    $kameleoonClient->evaluateAudiences($visitorCode);
} catch (Kameleoon\Exception\KameleoonException $e) {
    // Handling the exception
}

try {
    $dataFile = $kameleoonClient->getDataFile();
} catch (Kameleoon\Exception\KameleoonException $e) {
    // Recommended (but optional) safeguard for unexpected exceptions from third-party libraries
}

require "vendor/autoload.php";

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

$visitorCode = $kameleoonClient->getVisitorCode();

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

// Add a single data item (tracked by default)
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Browser(Kameleoon\Data\Browser::CHROME));

// Add multiple data items (tracked by default)
$kameleoonClient->addData(
    $visitorCode,
    new Kameleoon\Data\PageView("https://url.com", "title", [3]),
    new Kameleoon\Data\UserAgent("UserAgent")
);

// Add multiple data items stored locally for targeting only (not sent to the Kameleoon Data API)
$kameleoonClient->addData(
    $visitorCode,
    false,
    new Kameleoon\Data\PageView("https://url.com", "title", [3]),
    new Kameleoon\Data\UserAgent("UserAgent")
);

$visitorCode = $kameleoonClient->getVisitorCode();

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

$kameleoonClient->flush($visitorCode); // Interval tracking, non-blocking operation

$kameleoonClient->flush($visitorCode, null, null, true); // Instant tracking, blocking operation

// if you operate with unique ID
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\UniqueIdentifier(true));
$kameleoonClient->flush($visitorCode);

$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
}

$visitorCode = "visitorCode";

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

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

$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
);

$visitorCode = $kameleoonClient->getVisitorCode();
$kameleoonClient->setLegalConsent($visitorCode, true);

$engineTrackingCode = $kameleoonClient->getEngineTrackingCode($visitorCode);

require "vendor/autoload.php";

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

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

// if you operate with unique ID
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\UniqueIdentifier(true));
$kameleoonClient->trackConversion($visitorCode, $goalID, 0.0);

// Add metadata
$cd = new Kameleoon\Data\CustomData(1, "metadata");
$kameleoonClient->trackConversion($visitorCode, $goalID, 0.0, null, null, false, [$cd]);

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Browser(Kameleoon\Data\Browser::CHROME));

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Browser(Kameleoon\Data\Browser::CHROME, 10.0));

$kameleoonClient->addData(
    $visitorCode,
    new Kameleoon\Data\PageView("https://url.com", "title", [3])
);

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Conversion(32, 10, false));

$cd = new Kameleoon\Data\CustomData(1, "metadata");
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Conversion(32, 0.0, false, [$cd]));

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\CustomData(1, "value"));

// With several values
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\CustomData(1, "value1", "value2"));

// To set the 'overwrite' flag to false
$kameleoonClient->addData($visitorCode, Kameleoon\Data\CustomData::newWithOverwrite(1, false, "value"));

// To use a name instead of the index
$kameleoonClient->addData($visitorCode, new Kameleoon\Data\CustomData("my-custom-data", "value"));

// To use a name instead of the index
// and set the 'overwrite' flag to false
$kameleoonClient->addData($visitorCode, Kameleoon\Data\CustomData::newWithOverwrite("my-custom-data", false, "value"));

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Device(Kameleoon\Data\Device::PHONE));

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\UserAgent("TestUserAgent"));

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\UniqueIdentifier(true));

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\OperatingSystem(Kameleoon\Data\OperatingSystem::WINDOWS));

$cookie = new Kameleoon\Data\Cookie([
   "k1" => "v1",
   "k2" => "v2",
]);
$kameleoonClient->addData($visitorCode, $cookie);

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\Geolocation("France", "Île-de-France", "Paris"));

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\ApplicationVersion("10")); // major

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\ApplicationVersion("10.20")); // major.minor

$kameleoonClient->addData($visitorCode, new Kameleoon\Data\ApplicationVersion("10.20.30")); // major.minor.patch

// Retrieves the array of feature flags from the DataFile.
// The array is keyed by feature flag identifiers, with each value being a FeatureFlag object.
$featureFlags = $dataFile->featureFlags;

// Retrieves the last modification timestamp of the DataFile.
// The value is an int representing milliseconds since the Unix epoch.
$dateModified = $dataFile->getDateModified();

// Check whether the feature flag is enabled in the current environment
$isEnvironmentEnabled = $featureFlag->isEnvironmentEnabled;

// Retrieve the key of the default variation
$defaultVariationKey = $featureFlag->defaultVariationKey;

// Retrieve the default variation object
$defaultVariation = $featureFlag->getDefaultVariation();

// Retrieve all variations of the feature flag as a map (key = variation key, value = Variation object)
$variations = $featureFlag->variations;

// Retrieve all targeting rules associated with the feature flag
$rules = $featureFlag->rules;

// Retrieve all variations of the rule as a map (key = variation key, value = Variation object)
$variations = $rule->variations;

// Retrieving the variation name
$variationName = $variation->name;

// Retrieving the variation key
$variationKey = $variation->key;

// Retrieving the variation id
$variationId = $variation->id;

// Retrieving the experiment id
$experimentId = $variation->experimentId;

// Retrieving the variables map
$variables = $variation->variables;

// Retrieving the variables map
$variables = $variation->variables;

// Variable type can be retrieved for further processing
$type = $variables["isDiscount"]->type;

// Retrieving the variable value by key
$isDiscount = (bool) $variables["isDiscount"]->value;

// Variable value can be of different types
$title = (string) $variables["title"]->value;

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

try {
    $variationKey = $kameleoonClient->getFeatureVariationKey($visitorCode, $featureKey);
    switch ($variationKey) {
        case "on":
            // Main variation key is selected for visitorCode
            break;
        case "alternativeVariation":
            // Alternative variation key
            break;
        default:
            // Default variation key
            break;
    }
} 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 accepted.
} catch (Kameleoon\Exception\FeatureEnvironmentDisabled){
    // The feature flag is disabled for the environment.
} catch (Exception $e) {
    // This is a generic Exception handler which will handle all exceptions.
    echo "Exception: ",  $e->getMessage(), "\n";
}

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

$visitorCode = "visitor";
$arrayActiveFeatures = $kameleoonClient->getActiveFeatures($visitorCode);

$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 accepted.
} 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 a generic Exception handler which will handle all exceptions.
    echo "Exception: " . $e->getMessage() . "\n";
}

$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, i.e., 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 a generic Exception handler which will handle all exceptions.
    echo "Exception: " . $e->getMessage() . "\n";
}

$arrayFeatureKeys = $kameleoonClient->getFeatureList();