PHP SDK

composer require growthbook/growthbook

// Create a GrowthBook instance
$growthbook = Growthbook\Growthbook::create()
  ->withAttributes([
    // Targeting attributes
    'id' => $userId,
    'someCustomAttribute' => true
  ]);

// Load feature flags from the GrowthBook API
// Make sure to use caching in production! (see 'Loading Features' below)
// Note: Prior to version 1.7.0, this method was called `loadFeatures` instead of `initialize`
$growthbook->initialize("sdk-abc123", "https://cdn.growthbook.io");

// Feature gating
if ($growthbook->isOn("my-feature")) {
  echo "It's on!";
} else {
  echo "It's off :(";
}

// Remote configuration with fallback
$color = $growthbook->getValue("button-color", "blue");
echo "<button style='color:${color}'>Click Me!</button>";

$impressions = $growthbook->getViewedExperiments();
foreach($impressions as $impression) {
  // Whatever you use for event tracking
  Segment::track([
    "userId" => $userId,
    "event" => "Experiment Viewed",
    "properties" => [
      "experimentId" => $impression->experiment->key,
      "variationId" => $impression->result->key
    ]
  ]);
}

// Any psr-16 library will work
use Cache\Adapter\Apcu\ApcuCachePool;

$cache = new ApcuCachePool();

$growthbook = Growthbook\Growthbook::create()
  ->withCache($cache);

// You can optionally pass in a TTL (default 60s)
$growthbook = Growthbook\Growthbook::create()
  ->withCache($cache, 120); // Cache for 120s instead

// From the GrowthBook API, a custom cache layer, or somewhere else
$featuresJSON = '{"my-feature":{"defaultValue":true}}';

// Decode into an associative array
$features = json_decode($featuresJSON, true);

// Pass into the Growthbook instance
$growthbook = Growthbook\Growthbook::create()
  ->withFeatures($features);

// Optionally, if using saved groups
$savedGroupsJSON = '{"myGroup": [1, 2, 3]}';
$savedGroups = json_decode($savedGroupsJSON, true);
$growthbook = $growthbook->withSavedGroups($savedGroups);

// Using the fluent interface
$growthbook = Growthbook\Growthbook::create()
  ->withFeatures($features)
  ->withAttributes($attributes);

// Using the constructor
$growthbook = new Growthbook\Growthbook([
  'features' => $features,
  'attributes' => $attributes
]);

// Getter methods
print_r($growthbook->getFeatures());
print_r($growthbook->getAttributes());

$attributes = [
  'id' => "123",
  'loggedIn' => true,
  'deviceId' => "abc123def456",
  'age' => 21,
  'tags' => ["tag1", "tag2"],
  'account' => [
    'age' => 90
  ]
];

// Only update the url attribute
$growthbook->withAttributes(array_merge(
  $growthbook->getAttributes(),
  [
    'url' => '/checkout'
  ]
));

$trackingCallback = function (
  Growthbook\InlineExperiment $experiment,
  Growthbook\ExperimentResult $result
) {
  // Segment.io example
  Segment::track([
    "userId" => $userId,
    "event" => "Experiment Viewed",
    "properties" => [
      "experimentId" => $experiment->key,
      "variationId" => $result->key
    ]
  ]);
};

// Fluent interface
$growthbook = Growthbook\Growthbook::create()
  ->withTrackingCallback($callback);

// Using the constructor
$growthbook = new Growthbook([
  'trackingCallback' => $trackingCallback
]);

// Getter method
$trackingCallback = $growthbook->getTrackingCallback();

$impressions = $growthbook->getViewedExperiments();
foreach($impressions as $impression) {
  // Segment.io example
  Segment::track([
    "userId" => $userId,
    "event" => "Experiment Viewed",
    "properties" => [
      "experimentId" => $impression->experiment->key,
      "variationId" => $impression->result->key
    ]
  ]);
}

<script>
<?php foreach($growthbook->getViewedExperiments() as $impression): ?>
  // tracking code goes here
<?php endforeach; ?>
</script>

ga('send', 'event', 'experiment',
  "<?= $impression->experiment->key ?>",
  "<?= $impression->result->variationId ?>",
  {
    // Custom dimension for easier analysis
    'dimension1': "<?=
      $impression->experiment->key.':'.$impression->result->key
    ?>"
  }
);

analytics.track("Experiment Viewed", <?=json_encode([
  "experimentId" => $impression->experiment->key,
  "variationId" => $impression->result->key
])?>);

mixpanel.track("Experiment Viewed", <?=json_encode([
  'Experiment name' => $impression->experiment->key,
  'Variant name' => $impression->result->key
])?>);

// Fluent interface
$growthbook
  ->withLogger($logger)
  ->with...;

// Setter
$growthbook->setLogger($logger);

class InMemoryStickyBucketService extends StickyBucketService
{
    /** @var array<string, StickyAssignmentDocument>  */
    public array $docs = [];

    /**
     * @param string $attributeName
     * @param mixed $attributeValue
     * @return StickyAssignmentDocument|null
     */
    public function getAssignments(string $attributeName, $attributeValue): ?StickyAssignmentDocument
    {
        return $this->docs[$this->getKey($attributeName, $attributeValue)] ?? null;
    }

    /**
     * @param StickyAssignmentDocument $doc
     * @return void
     */
    public function saveAssignments(StickyAssignmentDocument $doc): void
    {
        $this->docs[$this->getKey($doc->getAttributeName(), $doc->getAttributeValue())] = $doc;
    }

    /**
     * @return void
     */
    public function destroy(): void
    {
        $this->docs = [];
    }
}

// Fluent interface
$growthbook = Growthbook\Growthbook::create()
  ->withStickyBucketing(new InMemoryStickyBucketService());

// Using the constructor
$growthbook = new Growthbook([
  'stickyBucketService' => new InMemoryStickyBucketService()
]);

$exp = Growthbook\InlineExperiment::create(
  "my-experiment",
  ["red", "blue", "green"]
);

// Either "red", "blue", or "green"
echo $growthbook->runInlineExperiment($exp)->value;

$exp = Growthbook\InlineExperiment::create("my-experiment", ["red","blue"])
  // Run a 40/60 experiment instead of the default even split (50/50)
  ->withWeights([0.4, 0.6])
  // Only include 20% of users in the experiment
  ->withCoverage(0.2)
  // Targeting conditions using a MongoDB-like syntax
  ->withCondition([
    'country' => 'US',
    'browser' => [
      '$in' => ['chrome', 'firefox']
    ]
  ])
  // Use an alternate attribute for assigning variations (default is 'id')
  ->withHashAttribute("sessionId")
  // Namespaces are used to run mutually exclusive experiments
  // Another experiment in the "pricing" namespace with a non-overlapping range
  //   will be mutually exclusive (e.g. [0.5, 1])
  ->withNamespace("pricing", 0, 0.5);

$result = $growthbook->runInlineExperiment($exp);

// If user is part of the experiment
echo($result->inExperiment); // true or false

// The index of the assigned variation
echo($result->variationId); // e.g. 0 or 1

// The key used to identify this variation when tracking the event
echo($result->key); // e.g. "control"

// The value of the assigned variation
echo($result->value); // e.g. "A" or "B"

// If the variations was randomly assigned based on a hash
echo($result->hashUsed); // true or false

// The user attribute that was hashed
echo($result->hashAttribute); // "id"

// The value of that attribute
echo($result->hashValue); // e.g. "123"