PHPackages                             vwo/vwo-fme-php-sdk - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. vwo/vwo-fme-php-sdk

ActiveLibrary

vwo/vwo-fme-php-sdk
===================

VWO server side sdk

1.22.0(2mo ago)521.6k↓22.1%31Apache-2.0PHPCI passing

Since Jun 11Pushed 2mo ago6 watchersCompare

[ Source](https://github.com/wingify/vwo-fme-php-sdk)[ Packagist](https://packagist.org/packages/vwo/vwo-fme-php-sdk)[ RSS](/packages/vwo-vwo-fme-php-sdk/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (10)Dependencies (10)Versions (37)Used By (1)

VWO Feature Management and Experimentation SDK for PHP
======================================================

[](#vwo-feature-management-and-experimentation-sdk-for-php)

[![Latest Stable Version](https://camo.githubusercontent.com/3de1c9683a567eb693046d0466312ec70ec7891e486e51c5889a3bc312fc760b/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f76776f2f76776f2d666d652d7068702d73646b2e7376673f7374796c653d666f722d7468652d6261646765)](https://packagist.org/packages/vwo/vwo-fme-php-sdk)[![License](https://camo.githubusercontent.com/41d17e54e8f801cf57a4a750fd161bb9fe1eebb48634ae8ba0bd285575f0756d/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f6c6963656e73652f77696e676966792f76776f2d666d652d6e6f64652d73646b3f7374796c653d666f722d7468652d626164676526636f6c6f723d626c7565)](http://www.apache.org/licenses/LICENSE-2.0)

[![CI](https://camo.githubusercontent.com/98cf340c6d5b6943ed8bf8bb6536a253a7e1e8bef49bfcca519af42d77144698/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f77696e676966792f76776f2d666d652d7068702d73646b2f6d61696e2e796d6c3f7374796c653d666f722d7468652d6261646765266c6f676f3d676974687562)](https://github.com/wingify/vwo-fme-php-sdk/actions?query=workflow%3ACI)[![codecov](https://camo.githubusercontent.com/9e025ff30de9f16f6e7028a61c07bb95d137884039cdc68023f36f1d0d380a3c/68747470733a2f2f696d672e736869656c64732e696f2f636f6465636f762f632f6769746875622f77696e676966792f76776f2d666d652d7068702d73646b3f746f6b656e3d3831335559594d57474d267374796c653d666f722d7468652d6261646765266c6f676f3d636f6465636f76)](https://codecov.io/gh/wingify/vwo-fme-php-sdk)

Overview
--------

[](#overview)

The **VWO Feature Management and Experimentation SDK** (VWO FME Php SDK) enables php developers to integrate feature flagging and experimentation into their applications. This SDK provides full control over feature rollout, A/B testing, and event tracking, allowing teams to manage features dynamically and gain insights into user behavior.

Requirements
------------

[](#requirements)

- **PHP 7.0 and onwards**

Installation
------------

[](#installation)

Install the latest version with

```
composer require vwo/vwo-fme-php-sdk
```

Basic Usage Example
-------------------

[](#basic-usage-example)

The following example demonstrates initializing the SDK with a VWO account ID and SDK key, setting a user context, checking if a feature flag is enabled, and tracking a custom event.

```
$vwoClient = VWO::init([
  'sdkKey' => 'vwo_sdk_key',
  'accountId' => 'vwo_account_id',
]);

// set user context
$userContext = [ 'id' => 'unique_user_id'];

// returns a flag object
$getFlag = $vwoClient->getFlag('feature_key', $userContext);

// check if flag is enabled
$isFlagEnabled = $getFlag['isEnabled'];

// get variable
$variableValue = $getFlag->getVariable('variable_key', 'default-value');

// track event
$trackRes = $vwoClient->trackEvent('event_name', $userContext);

// set Attribute
$attributes = [
  'attribute_key' => 'attribute_value'
];
$setAttribute = $vwoClient->setAttribute($attributes, $userContext);
```

Advanced Configuration Options
------------------------------

[](#advanced-configuration-options)

To customize the SDK further, additional parameters can be passed to the `init()` API. Here's a table describing each option:

**Parameter****Description****Required****Type****Example**`sdkKey`SDK key corresponding to the specific environment to initialize the VWO SDK Client. You can get this key from VWO Application.Yesstring`'32-alpha-numeric-sdk-key'``accountId`VWO Account ID for authentication.Yesstring`'123456'``gatewayService`An object representing configuration for integrating VWO Gateway Service.Noarraysee [Gateway](#gateway) section`proxy`An object representing configuration for routing all SDK network requests through a custom proxy server.NoarraySee [Proxy](#proxy) section`storage`Custom storage connector for persisting user decisions and campaign data.NoarraySee [Storage](#storage) section`logger`Toggle log levels for more insights or for debugging purposes. You can also customize your own transport in order to have better control over log messages.NoarraySee [Logger](#logger) section`Integrations`Callback function for integrating with third-party analytics services.NoobjectSee [Integrations](#integrations) sectionRefer to the [official VWO documentation](https://developers.vwo.com/v2/docs/fme-php-install) for additional parameter details.

### User Context

[](#user-context)

The `context` array uniquely identifies users and is crucial for consistent feature rollouts. A typical `context` includes an `id` for identifying the user. It can also include other attributes that can be used for targeting and segmentation, such as `customVariables`, `userAgent` and `ipAddress`.

#### Parameters Table

[](#parameters-table)

The following table explains all the parameters in the `context` array:

**Parameter****Description****Required****Type****Example**`id`Unique identifier for the user.Yesstring`'unique_user_id'``customVariables`Custom attributes for targeting.Noarray`['age' => 25, 'location' => 'US']``userAgent`User agent string for identifying the user's browser and operating system.Nostring`'Mozilla/5.0 ... Safari/537.36'``ipAddress`IP address of the user.Nostring`'1.1.1.1'``bucketingSeed`Custom seed for bucketing logic instead of user ID.Nostring`'custom_seed_value'`#### Example

[](#example)

```
$userContext = [
  'id' => 'unique_user_id',
  'customVariables' => ['age' => 25, 'location' => 'US'],
  'userAgent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
  'ipAddress' => '1.1.1.1',
  'bucketingSeed' => 'custom_seed_value', // Optional: overrides userId for bucketing
];
```

### Basic Feature Flagging

[](#basic-feature-flagging)

Feature Flags serve as the foundation for all testing, personalization, and rollout rules within FME. To implement a feature flag, first use the `getFlag` API to retrieve the flag configuration. The `getFlag` API provides a simple way to check if a feature is enabled for a specific user and access its variables. It returns a feature flag object that contains methods for checking the feature's status and retrieving any associated variables.

ParameterDescriptionRequiredTypeExample`featureKey`Unique identifier of the feature flagYesstring`'new_checkout'``context`Array containing user identification and contextual informationYesarray`['id' => 'user_123']`Example usage:

```
$featureFlag = $vwoClient->getFlag('feature_key', $userContext);
$isEnabled = $featureFlag->isEnabled();

if ($isEnabled) {
  echo 'Feature is enabled!';

  // Get and use feature variable with type safety
  $variableValue = $featureFlag->getVariable('feature_variable', 'default_value');
  echo 'Variable value:', $variableValue;
} else {
  echo 'Feature is not enabled!';
}
```

### Custom Event Tracking

[](#custom-event-tracking)

Feature flags can be enhanced with connected metrics to track key performance indicators (KPIs) for your features. These metrics help measure the effectiveness of your testing rules by comparing control versus variation performance, and evaluate the impact of personalization and rollout campaigns. Use the `trackEvent` API to track custom events like conversions, user interactions, and other important metrics:

ParameterDescriptionRequiredTypeExample`eventName`Name of the event you want to trackYesstring`'purchase_completed'``context`Array containing user identification and contextual informationYesarray`['id' => 'user_123']``eventProperties`Additional properties/metadata associated with the eventNoarray`['amount' => 49.99]`Example usage:

```
$vwoClient->trackEvent('event_name', $userContext, $eventProperties);
```

See [Tracking Conversions](https://developers.vwo.com/v2/docs/fme-php-metrics#usage) documentation for more information.

### Pushing Attributes

[](#pushing-attributes)

User attributes provide rich contextual information about users, enabling powerful personalization. The `setAttribute` method provides a simple way to associate these attributes with users in VWO for advanced segmentation. Here's what you need to know about the method parameters:

ParameterDescriptionRequiredTypeExample`attributeKey`The unique identifier/name of the attribute you want to setYesstring`'plan_type'``attributeValue`The value to be assigned to the attributeYesstring/int/boolean`'premium'`, `25`, `true``context`Array containing user identification and contextual informationYesarray`['id' => 'user_123']`Example usage:

```
$vwoClient->setAttribute('attribute_name', 'attribute_value', $userContext);
```

Or

```
$attributes = [
  'attribute_name' => 'attribute_value'
];
$vwoClient->setAttribute($attributes, $userContext);
```

See [Pushing Attributes](https://developers.vwo.com/v2/docs/fme-php-attributes#usage) documentation for additional information.

### Generating UUID

[](#generating-uuid)

The `getUUID` method allows you to generate a UUID that gets stored on VWO by providing a `userId` and `accountId`. This UUID is generated using a deterministic algorithm based on the user and account identifiers, ensuring consistent UUID generation for the same user-account combination.

**Parameter****Description****Required****Type****Example**`userId`The unique identifier for the userYesString`'user-123'``accountId`The account IDYesString`'123456'`#### Return Value

[](#return-value)

Returns a UUID string formatted without dashes and in uppercase (e.g., `'CC25A368ADA0542699EAD62489811105'`).

#### Example Usage

[](#example-usage)

```
use vwo\VWO;

// Generate UUID for a user
$userId = 'user-123';
$accountId = '123456';
$uuid = VWO::getUUID($userId, $accountId);

echo 'Generated UUID:', $uuid;
// Output: Generated UUID: CC25A368ADA0542699EAD62489811105
```

### Custom Bucketing Seed

[](#custom-bucketing-seed)

By default, the SDK uses the user's `id` to determine which variation or feature a user is bucketed into. The `bucketingSeed` parameter lets you override this behavior by providing a custom string for bucketing calculations.

This is useful when you want to:

- Ensure consistent bucketing across different user identifiers or SDKs
- Group different users into the same bucket by using a shared seed

```
// Two different users bucketed the same way using a shared seed
$context1 = ['id' => 'user_1', 'bucketingSeed' => 'shared_seed'];
$context2 = ['id' => 'user_2', 'bucketingSeed' => 'shared_seed'];

// Both will receive the same variation
$flag1 = $vwoClient->getFlag('feature_key', $context1);
$flag2 = $vwoClient->getFlag('feature_key', $context2);
```

### Polling Interval Adjustment

[](#polling-interval-adjustment)

The `pollInterval` is an optional parameter that allows the SDK to automatically fetch and update settings from the VWO server at specified intervals. Setting this parameter ensures your application always uses the latest configuration.

```
$vwoClient = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'pollInterval' => 60000,
]);
```

### Gateway

[](#gateway)

The VWO FME Gateway Service is an optional but powerful component that enhances VWO's Feature Management and Experimentation (FME) SDKs. It acts as a critical intermediary for pre-segmentation capabilities based on user location and user agent (UA). By deploying this service within your infrastructure, you benefit from minimal latency and strengthened security for all FME operations.

#### Why Use a Gateway?

[](#why-use-a-gateway)

The Gateway Service is required in the following scenarios:

- When using pre-segmentation features based on user location or user agent.
- For applications requiring advanced targeting capabilities.
- It's mandatory when using any thin-client SDK (e.g., Go).

#### How to Use the Gateway

[](#how-to-use-the-gateway)

The gateway can be customized by passing the `gatewayService` parameter in the `init` configuration.

```
$vwoClient = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'gatewayService' => [
    'url' => 'https://custom.gateway.com',
  ],
]);
```

Refer to the [Gateway Documentation](https://developers.vwo.com/v2/docs/gateway-service) for further details.

### Proxy

[](#proxy)

The `proxy` parameter allows you to redirect all SDK network calls through a custom proxy URL. This feature enables you to route all SDK network requests (settings, tracking, etc.) through your own proxy server, providing better control over network traffic and security.

```
$vwoClient = VWO::init([
    'sdkKey' => '32-alpha-numeric-sdk-key',
    'accountId' => 123456,
    'proxy' => [
        'url' => 'http://custom.proxy.com',
        'isUrlNotSecure' => false // be default, it should be true
    ],
]);
```

The `proxy` object accepts the following parameters:

**Parameter****Description****Required****Type****Example**`url`The proxy server URL to route all SDK network requests throughYesstring`'http://localhost:8000'``isUrlNotSecure`Set to `true` if the proxy URL uses HTTP (not HTTPS). Defaults to `false` (HTTPS)Noboolean`true`### Synchronous network calls

[](#synchronous-network-calls)

Synchronous network calls differ from the default (asynchronous or fire-and-forget) tracking behavior by waiting for the tracking request to return a response from the VWO server before proceeding with the rest of your application code. By default, the SDK sends tracking network calls in a way that does not block your application, providing maximum throughput and lowest latency for user actions.

**Why is it so?**

- The default asynchronous approach ensures minimal impact on user experience or application response times. Tracking calls are dispatched without waiting for a server response.
- With synchronous calls enabled (`shouldWaitForTrackingCalls => true`), your code will block and wait for the network call to complete, allowing you to detect network errors, retry, and ensure delivery before execution continues.

**When should you use synchronous calls?**

- Use synchronous tracking when tracking data integrity or acknowledgment is critical before user flow continues (e.g., checkout flows, conversion confirmations, or compliance events).
- It is recommended when you need to guarantee that server-side events are delivered, and are willing to trade a slight increase in user-facing latency for this assurance.

You can opt-in to perform network calls synchronously by passing an init parameter.

```
$vwoClient = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'shouldWaitForTrackingCalls' => true,
]);
```

Notes:

- In PHP, the default transport for tracking is a non-blocking socket-based call (fire-and-forget).
- When you enable `shouldWaitForTrackingCalls`, the SDK switches to a blocking cURL-based call so your code waits for the response.
- For synchronous (cURL) calls, retry is enabled by default. You can override via `retryConfig` in init:

```
$vwoClient = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'shouldWaitForTrackingCalls' => true,
  'retryConfig' => [
    'shouldRetry' => true,        // default: true
    'maxRetries' => 3,            // default: 3
    'initialDelay' => 2,          // seconds; default: 2
    'backoffMultiplier' => 2,     // delays: 2s, 4s, 8s; default: 2
  ],
]);
```

If you want synchronous calls but without retries, set `shouldRetry` to `false`:

```
$vwoClient = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'shouldWaitForTrackingCalls' => true,
  'retryConfig' => [
    'shouldRetry' => false,
  ],
]);
```

### Storage

[](#storage)

The SDK operates in a stateless mode by default, meaning each `getFlag` call triggers a fresh evaluation of the flag against the current user context.

To optimize performance and maintain consistency, you can implement a custom storage mechanism by passing a `storage` parameter during initialization. This allows you to persist feature flag decisions in your preferred database system (like Redis, MongoDB, or any other data store).

Key benefits of implementing storage:

- Improved performance by caching decisions
- Consistent user experience across sessions
- Reduced load on your application

The storage mechanism ensures that once a decision is made for a user, it remains consistent even if campaign settings are modified in the VWO Application. This is particularly useful for maintaining a stable user experience during A/B tests and feature rollouts.

```
class StorageConnector {
   private $map = [];

   public function get($featureKey, $userId) {
    $key = $featureKey . '_' . $userId;
    return isset($this->map[$key]) ? $this->map[$key] : null;
   }

   public function set($data) {
    $key = $data['featureKey'] . '_' . $data['user'];
    // Implement your storage logic here to store the data in your preferred database system using $key
   }
}

// Initialize the StorageConnector
$storageConnector = new StorageConnector();

$vwoClient = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'storage' => $storageConnector,
]);
```

### Logger

[](#logger)

VWO by default logs all `ERROR` level messages to your server console. To gain more control over VWO's logging behaviour, you can use the `logger` parameter in the `init` configuration.

**Parameter****Description****Required****Type****Example**`level`Log level to control verbosity of logsYesstring`'DEBUG'``prefix`Custom prefix for log messagesNostring`'CUSTOM LOG PREFIX'``isAnsiColorEnabled`Enable ANSI color codes for log levels in terminal outputNoboolean`true``transport`Custom logger implementationNoarraySee example below#### Example 1: Set log level to control verbosity of logs

[](#example-1-set-log-level-to-control-verbosity-of-logs)

```
$vwoClient1 = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'logger' => [
    'level' => 'DEBUG',
  ],
]);
```

#### Example 2: Add custom prefix to log messages for easier identification

[](#example-2-add-custom-prefix-to-log-messages-for-easier-identification)

```
$vwoClient2 = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'logger' => [
    'level' => 'DEBUG',
    'prefix' => 'CUSTOM LOG PREFIX',
  ],
]);
```

#### Example 3: Enable ANSI color codes for colored log levels in terminal

[](#example-3-enable-ansi-color-codes-for-colored-log-levels-in-terminal)

```
$vwoClient3 = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'accountId' => '123456',
  'logger' => [
    'level' => 'DEBUG',
    'isAnsiColorEnabled' => true, // Enable colored log levels (TRACE, DEBUG, INFO, WARN, ERROR)
  ],
]);
```

Note: ANSI color codes are only applied when `isAnsiColorEnabled` is explicitly set to `true`. This prevents unwanted color codes in log files or non-terminal outputs. When disabled or not set, log levels are displayed as plain text.

#### Example 4: Implement custom transport to handle logs your way

[](#example-4-implement-custom-transport-to-handle-logs-your-way)

The `transport` parameter allows you to implement custom logging behavior by providing your own logging functions. You can define handlers for different log levels (`debug`, `info`, `warn`, `error`, `trace`) to process log messages according to your needs.

For example, you could:

- Send logs to a third-party logging service
- Write logs to a file
- Format log messages differently
- Filter or transform log messages
- Route different log levels to different destinations

The transport object should implement handlers for the log levels you want to customize. Each handler receives the log message as a parameter.

For single transport you can use the `transport` parameter. For example:

```
$vwoClient4 = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'logger' => [
    'transport' => [
        'level' => 'DEBUG',
        'logHandler' => function($msg, $level){
          echo "$msg $level";
        }
    ],
  ]
]);
```

For multiple transports you can use the `transports` parameter. For example:

```
$vwoClient5 = VWO::init([
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'logger' => [
    'transports' => [
        [
            'level' => 'DEBUG',
            'logHandler' => function($msg, $level){
              echo "$msg $level";
            }
        ],
        [
            'level' => 'INFO',
            'logHandler' => function($msg, $level){
              echo "$msg $level";
            }
        ]
    ]
  ]
]);
```

### Integrations

[](#integrations)

VWO FME SDKs provide seamless integration with third-party tools like analytics platforms, monitoring services, customer data platforms (CDPs), and messaging systems. This is achieved through a simple yet powerful callback mechanism that receives VWO-specific properties and can forward them to any third-party tool of your choice.

```
function callback($properties) {
    // properties will contain all the required VWO specific information
    echo json_encode($properties);
}

$options = [
    'sdkKey' => '32-alpha-numeric-sdk-key', // SDK Key
    'accountId' => '12345', // VWO Account ID
    'integrations' => [
        'callback' => 'callback'
    ]
];

$vwoClient = VWO::init($options);
```

### User Aliasing

[](#user-aliasing)

User aliasing lets you associate an existing user ID with an alternate ID (alias) so future evaluations and tracking use a unified identity across systems.

Requirements:

- Gateway must be configured
- Aliasing must be enabled during initialization: `isAliasingEnabled: true`

Initialization example:

```
$vwoClient = VWO::init([
  'accountId' => '123456',
  'sdkKey' => '32-alpha-numeric-sdk-key',
  'isAliasingEnabled' => true,
  'gatewayService' => [ 'url' => 'https://custom.gateway.com' ],
]);
```

Usage examples:

```
// Using context array
$success1 = $vwoClient->setAlias(['id' => 'user-123'], 'alias-abc');

// Using direct userId
$success2 = $vwoClient->setAlias('user-123', 'alias-abc');
```

Behavior and validations:

- Returns `true` on success, `false` otherwise
- Requires aliasing to be enabled and gateway configured
- `aliasId` must be a non-empty string (not an array); it is trimmed before use
- When passing context, `context['id']` must be a non-empty string (not an array); it is trimmed before use
- `userId` and `aliasId` cannot be the same

### Version History

[](#version-history)

The version history tracks changes, improvements, and bug fixes in each version. For a full history, see the [CHANGELOG.md](https://github.com/wingify/vwo-fme-php-sdk/blob/master/CHANGELOG.md).

Development and Testing
-----------------------

[](#development-and-testing)

1. Set development environment

```
composer run-script start
```

2. Run test cases

```
composer run-script test
```

### Contributing

[](#contributing)

Please go through our [contributing guidelines](https://github.com/wingify/vwo-fme-php-sdk/blob/master/CONTRIBUTING.md)

### Code of Conduct

[](#code-of-conduct)

[Code of Conduct](https://github.com/wingify/vwo-fme-php-sdk/blob/master/CODE_OF_CONDUCT.md)

### License

[](#license)

[Apache License, Version 2.0](https://github.com/wingify/vwo-fme-php-sdk/blob/master/LICENSE)

Copyright 2024-2025 Wingify Software Pvt. Ltd.

###  Health Score

51

—

FairBetter than 96% of packages

Maintenance88

Actively maintained with recent releases

Popularity34

Limited adoption so far

Community20

Small or concentrated contributor base

Maturity52

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 67.4% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~19 days

Recently: every ~8 days

Total

35

Last Release

62d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/45913410?v=4)[Katsuyo](/maintainers/vwo)[@vwo](https://github.com/vwo)

---

Top Contributors

[![sakshamg1304](https://avatars.githubusercontent.com/u/62280087?v=4)](https://github.com/sakshamg1304 "sakshamg1304 (29 commits)")[![softvar](https://avatars.githubusercontent.com/u/4180800?v=4)](https://github.com/softvar "softvar (6 commits)")[![Abhi591](https://avatars.githubusercontent.com/u/59906686?v=4)](https://github.com/Abhi591 "Abhi591 (4 commits)")[![Kaustubh22327](https://avatars.githubusercontent.com/u/118050234?v=4)](https://github.com/Kaustubh22327 "Kaustubh22327 (1 commits)")[![Pawan-yadav266](https://avatars.githubusercontent.com/u/102517154?v=4)](https://github.com/Pawan-yadav266 "Pawan-yadav266 (1 commits)")[![sakshamGupta1999](https://avatars.githubusercontent.com/u/176903285?v=4)](https://github.com/sakshamGupta1999 "sakshamGupta1999 (1 commits)")[![VwoWingi](https://avatars.githubusercontent.com/u/170556157?v=4)](https://github.com/VwoWingi "VwoWingi (1 commits)")

---

Tags

sdkvwofme

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/vwo-vwo-fme-php-sdk/health.svg)

```
[![Health](https://phpackages.com/badges/vwo-vwo-fme-php-sdk/health.svg)](https://phpackages.com/packages/vwo-vwo-fme-php-sdk)
```

###  Alternatives

[temporal/sdk

Temporal SDK

4002.2M18](/packages/temporal-sdk)[open-telemetry/sdk

SDK for OpenTelemetry PHP.

2322.9M248](/packages/open-telemetry-sdk)[vwo/vwo-php-sdk

VWO server side sdk

12166.4k](/packages/vwo-vwo-php-sdk)[liamcottle/instagram-sdk-php

This is an unofficial SDK for the Instagram Private API in PHP

1308.4k](/packages/liamcottle-instagram-sdk-php)[highsidelabs/walmart-api

A PHP client for Walmart's Marketplace, 1P Supplier, and Content Provider APIs.

308.0k](/packages/highsidelabs-walmart-api)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)